dineway 0.1.45 → 0.1.46

package/dist/cli/index.mjs

@@ -1,37 +1,40 @@
 #!/usr/bin/env node
-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 { i as runMigrations, n as getMigrationStatus, t as getMigrationFingerprint } from "../runner-DF2DgD_B.mjs";
-import { r as isI18nEnabled } from "../config-XW5tMrH8.mjs";
+import { a as __exportAll, i as runMigrations, n as getMigrationStatus, t as getMigrationFingerprint } from "../runner-DTfG5v0G.mjs";
+import { t as createDatabase } from "../connection-CiJWiWya.mjs";
+import { t as validateIdentifier } from "../validate-VPnKoIzW.mjs";
+import { l as listTablesLike } from "../dialect-helpers-fk43GbDb.mjs";
+import { r as isI18nEnabled } from "../config-CVssduLe.mjs";
 import { n as slugify } from "../slugify-BzGxlOFx.mjs";
-import { t as ContentRepository } from "../content-DvpMad_N.mjs";
+import { t as ContentRepository } from "../content-BfyjOiMi.mjs";
 import { i as encodeBase64url } from "../base64-C1Q9yr0B.mjs";
-import "../types-D1DjBFA9.mjs";
-import { t as MediaRepository } from "../media-Cg4zc9fq.mjs";
-import { t as TaxonomyRepository } from "../taxonomy-BvXRL85P.mjs";
+import "../types-Ck7-WoUD.mjs";
+import { t as MediaRepository } from "../media-DhBwiCYR.mjs";
+import { t as TaxonomyRepository } from "../taxonomy-BnH-6VsX.mjs";
 import { t as OptionsRepository } from "../options-BF11H_FD.mjs";
-import "../redirect-BaVvo2te.mjs";
-import "../byline-DpNNSjET.mjs";
-import "../request-cache-BpwuE2ix.mjs";
-import "../fts-manager-DnfOsF4s.mjs";
-import { n as SchemaRegistry } from "../registry-i__XP2WV.mjs";
-import "../loader-p2imNN98.mjs";
-import "../settings-DORe02PC.mjs";
-import { i as pluginManifestSchema } from "../manifest-schema-C6fzQoWn.mjs";
-import "../ssrf-KAIQS48_.mjs";
-import { t as validateSeed } from "../validate-JE-WfUQ5.mjs";
-import { t as applySeed } from "../apply-TIoQ00aH.mjs";
-import { n as fingerprintKey, r as generateEncryptionKey, t as DinewaySecretsError } from "../secrets-DfeNNoLa.mjs";
+import "../redirect-BqFMj67n.mjs";
+import "../request-cache-w5cj5itT.mjs";
+import "../byline-registry-CL8BxPPp.mjs";
+import { t as BylineRepository } from "../byline-CXQcMsBu.mjs";
+import "../fts-manager-EHY2Kes9.mjs";
+import { n as SchemaRegistry } from "../registry-Cq3QRBW2.mjs";
+import { a as isMissingTableError } from "../loader-Y0QvC_QO.mjs";
+import "../settings-DNRQuX3d.mjs";
+import { i as pluginManifestSchema } from "../manifest-schema-qh2P7RDX.mjs";
+import "../ssrf-DiKqWd3N.mjs";
+import { t as validateSeed } from "../validate-CK4a1sIF.mjs";
+import { t as applySeed } from "../apply-BpRBCqUt.mjs";
+import { n as fingerprintKey, r as generateEncryptionKey, t as DinewaySecretsError } from "../secrets-CN6FCpcB.mjs";
 import { createHeaderAwareFetch, customHeadersInterceptor, isRedirectResponse, resolveCustomHeaders } from "../client/external-auth-headers.mjs";
-import { o as convertDataForRead } from "../transport-B7kO-4ee.mjs";
+import { o as convertDataForRead } from "../transport-LSdZVXHF.mjs";
 import { DinewayClient } from "../client/index.mjs";
 import { LocalStorage } from "../storage/local.mjs";
 import { createHash } from "node:crypto";
+import { sql } from "kysely";
 import { imageSize } from "image-size";
 import { createGzipDecoder, unpackTar } from "modern-tar";
 import { createReadStream, createWriteStream, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
 import { defineCommand, runCommand, runMain } from "citty";
 import consola, { consola as consola$1 } from "consola";
 import pc from "picocolors";
@@ -718,6 +721,10 @@ const updateCommand = defineCommand({
 			description: "Revision token from get (prevents overwriting unseen changes)",
 			required: true
 		},
+		locale: {
+			type: "string",
+			description: "Locale for slug resolution"
+		},
 		draft: {
 			type: "boolean",
 			description: "Keep as draft instead of auto-publishing"
@@ -731,10 +738,11 @@ const updateCommand = defineCommand({
 			const client = createClientFromArgs(args);
 			const updated = await client.update(args.collection, args.id, {
 				data,
-				_rev: args.rev
+				_rev: args.rev,
+				locale: args.locale
 			});
-			if (!args.draft && updated.draftRevisionId) await client.publish(args.collection, args.id);
-			output(await client.get(args.collection, args.id), args);
+			if (!args.draft && updated.draftRevisionId) await client.publish(args.collection, updated.id);
+			output(await client.get(args.collection, updated.id), args);
 		} catch (error) {
 			consola$1.error(error instanceof Error ? error.message : "Unknown error");
 			process.exit(1);
@@ -1631,13 +1639,33 @@ async function writeForgewayDeployMetadata(cwd, metadata) {
 //#endregion
 //#region src/cli/commands/deploy/utils/forgeway-secrets.ts
 const DINEWAY_CONFIG_DIR_NAME = ".dineway";
-const TRAILING_SLASH_PATTERN$1 = /\/$/;
+const DINEWAY_USER_CONFIG_DIR_NAME = "dineway";
+const TRAILING_SLASH_PATTERN$2 = /\/$/;
 function getDinewayConfigDir(cwd = process.cwd()) {
 	return join(cwd, DINEWAY_CONFIG_DIR_NAME);
 }
+function getDinewayUserConfigDir() {
+	return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), DINEWAY_USER_CONFIG_DIR_NAME);
+}
 function getForgewaySecretPath(cwd = process.cwd()) {
 	return join(getDinewayConfigDir(cwd), "forgeway.json");
 }
+function getForgewayAccountSecretPath() {
+	return join(getDinewayUserConfigDir(), "forgeway.json");
+}
+function normalizePlatformApiUrl$1(platformApiUrl) {
+	return platformApiUrl.replace(TRAILING_SLASH_PATTERN$2, "");
+}
+function normalizeEmail$2(email) {
+	return email.trim().toLowerCase();
+}
+function accountKey(platformApiUrl, email) {
+	return `${normalizePlatformApiUrl$1(platformApiUrl)}#${normalizeEmail$2(email)}`;
+}
+function normalizeLookup(lookup) {
+	if (typeof lookup === "string") return { cwd: lookup };
+	return lookup ?? {};
+}
 async function readStore(cwd = process.cwd()) {
 	try {
 		const raw = await readFile(getForgewaySecretPath(cwd), "utf-8");
@@ -1658,16 +1686,66 @@ async function writeStore(store, cwd = process.cwd()) {
 	});
 	await chmod(file, 384);
 }
-async function readForgewayCredentials(cwd) {
-	return (await readStore(cwd)).credentials ?? null;
+async function readAccountStore() {
+	try {
+		const raw = await readFile(getForgewayAccountSecretPath(), "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return { version: 1 };
+	}
 }
-async function writeForgewayCredentials(credentials, cwd) {
-	const store = await readStore(cwd);
-	store.credentials = credentials;
-	await writeStore(store, cwd);
+async function writeAccountStore(store) {
+	await mkdir(getDinewayUserConfigDir(), {
+		recursive: true,
+		mode: 448
+	});
+	const file = getForgewayAccountSecretPath();
+	await writeFile(file, JSON.stringify({
+		...store,
+		version: 1
+	}, null, "	") + "\n", {
+		encoding: "utf-8",
+		mode: 384
+	});
+	await chmod(file, 384);
+}
+function accountMatches(credentials, lookup) {
+	if (lookup.platformApiUrl && normalizePlatformApiUrl$1(credentials.platformApiUrl) !== normalizePlatformApiUrl$1(lookup.platformApiUrl)) return false;
+	if (lookup.email && normalizeEmail$2(credentials.user?.email ?? "") !== normalizeEmail$2(lookup.email)) return false;
+	return true;
+}
+async function readForgewayCredentials(lookup) {
+	const normalizedLookup = normalizeLookup(lookup);
+	const store = await readAccountStore();
+	const accounts = Object.values(store.accounts ?? {}).filter((credentials) => accountMatches(credentials, normalizedLookup));
+	if (normalizedLookup.platformApiUrl && normalizedLookup.email) return store.accounts?.[accountKey(normalizedLookup.platformApiUrl, normalizedLookup.email)] ?? null;
+	if (accounts.length === 1) return accounts[0] ?? null;
+	return null;
+}
+async function writeForgewayCredentials(credentials, lookup) {
+	const normalizedLookup = normalizeLookup(lookup);
+	const platformApiUrl = normalizePlatformApiUrl$1(normalizedLookup.platformApiUrl ?? credentials.platformApiUrl);
+	const email = normalizeEmail$2(normalizedLookup.email ?? credentials.user?.email ?? "");
+	if (!email) throw new Error("Forgeway credentials require a user email before they can be stored.");
+	const key = accountKey(platformApiUrl, email);
+	const store = await readAccountStore();
+	store.accounts = {
+		...store.accounts,
+		[key]: {
+			...credentials,
+			platformApiUrl
+		}
+	};
+	store.lastAccountKey = key;
+	await writeAccountStore(store);
+}
+async function listForgewayCredentials(platformApiUrl) {
+	const lookup = platformApiUrl ? { platformApiUrl } : {};
+	const store = await readAccountStore();
+	return Object.values(store.accounts ?? {}).filter((credentials) => accountMatches(credentials, lookup));
 }
 function shadowGrantKey(platformApiUrl, placeId) {
-	return `${platformApiUrl.replace(TRAILING_SLASH_PATTERN$1, "")}#${placeId ?? "__unbound__"}`;
+	return `${platformApiUrl.replace(TRAILING_SLASH_PATTERN$2, "")}#${placeId ?? "__unbound__"}`;
 }
 async function readForgewayShadowGrant(platformApiUrl, placeId, cwd) {
 	const store = await readStore(cwd);
@@ -1690,7 +1768,7 @@ async function writeForgewayShadowGrant(grant, cwd) {
 
 //#endregion
 //#region src/cli/commands/deploy/targets/forgeway.ts
-const DEFAULT_DINEWAY_API_BASE_URL = "https://api.dineway.ai";
+const DEFAULT_DINEWAY_API_BASE_URL$1 = "https://api.dineway.ai";
 const DATABASE_ENV_VAR_NAMES = ["DINEWAY_DATABASE_URL", "DINEWAY_DATABASE_AUTH_TOKEN"];
 const POLL_INTERVAL_MS$1 = 5e3;
 const POLL_TIMEOUT_MS$1 = 3e5;
@@ -1705,9 +1783,9 @@ const NON_COMPARE_PATTERN = /[^\p{Letter}\p{Number}]+/gu;
 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 TRAILING_SLASH_PATTERN$1 = /\/$/;
 const BACKSLASH_PATTERN = /\\/g;
-const SHADOW_EMAIL_PATTERN = /^shadow_[a-f0-9]{16}@dineway\.ai$/i;
+const SHADOW_EMAIL_PATTERN$1 = /^shadow_[a-f0-9]{16}@dineway\.ai$/i;
 const OTP_PATTERN = /^\d{6}$/;
 const FOOD_TYPES = new Set([
 	"restaurant",
@@ -1756,7 +1834,7 @@ var ForgewayApiError = class extends Error {
 		this.name = "ForgewayApiError";
 	}
 };
-function normalizeForgewayUser(user) {
+function normalizeForgewayUser$1(user) {
 	return {
 		id: user.id,
 		name: user.profile?.name ?? user.name ?? user.email,
@@ -1777,7 +1855,7 @@ async function fileExists$8(path) {
 	}
 }
 function normalizePlatformApiUrl(value) {
-	return (value || DEFAULT_DINEWAY_API_BASE_URL).replace(TRAILING_SLASH_PATTERN, "");
+	return (value || DEFAULT_DINEWAY_API_BASE_URL$1).replace(TRAILING_SLASH_PATTERN$1, "");
 }
 function resolvePlatformApiUrl(savedPlatformApiUrl) {
 	return normalizePlatformApiUrl(getEnv("DINEWAY_API_BASE_URL") ?? (typeof savedPlatformApiUrl === "string" ? savedPlatformApiUrl : void 0));
@@ -1840,7 +1918,7 @@ async function parseErrorResponse(response) {
 	}
 	return `Forgeway request failed: ${response.status}`;
 }
-function normalizeEmail(email) {
+function normalizeEmail$1(email) {
 	return email.trim().toLowerCase();
 }
 function normalizeOtp(otp) {
@@ -1848,8 +1926,8 @@ function normalizeOtp(otp) {
 	if (!OTP_PATTERN.test(value)) throw new Error("Forgeway email verification OTP must be a 6-digit numeric code.");
 	return value;
 }
-function isShadowEmail(email) {
-	return Boolean(email && SHADOW_EMAIL_PATTERN.test(email));
+function isShadowEmail$1(email) {
+	return Boolean(email && SHADOW_EMAIL_PATTERN$1.test(email));
 }
 async function refreshFormalAccessToken(context, deps) {
 	if (!context.refreshToken) throw new Error("Forgeway formal account refresh token is missing. Run dineway deploy again.");
@@ -1861,19 +1939,22 @@ async function refreshFormalAccessToken(context, deps) {
 	if (!response.ok) throw new Error("Failed to refresh Forgeway formal account credentials. Run dineway deploy again.");
 	const payload = await response.json();
 	if (!payload.accessToken) throw new Error("Forgeway refresh response was missing accessToken.");
-	const user = assertVerifiedFormalAccountUser(payload.user ? normalizeForgewayUser(payload.user) : context.user, context.user?.email);
+	const user = assertVerifiedFormalAccountUser(payload.user ? normalizeForgewayUser$1(payload.user) : context.user, context.user?.email);
 	const updated = {
 		platformApiUrl: context.platformApiUrl,
 		accessToken: payload.accessToken,
 		refreshToken: payload.refreshToken ?? context.refreshToken,
 		...user ? { user } : {},
-		source: "shadow-email-upgrade",
-		...context.placeId ? { placeId: context.placeId } : {}
+		source: "shadow-email-upgrade"
 	};
 	context.accessToken = updated.accessToken;
 	context.refreshToken = updated.refreshToken;
 	context.user = updated.user;
-	await (deps.writeCredentials ?? writeForgewayCredentials)(updated, context.projectDir);
+	await (deps.writeCredentials ?? writeForgewayCredentials)(updated, {
+		cwd: context.projectDir,
+		platformApiUrl: context.platformApiUrl,
+		email: user.email
+	});
 	return payload.accessToken;
 }
 async function refreshShadowAccessToken(context, deps) {
@@ -1895,7 +1976,7 @@ async function refreshShadowAccessToken(context, deps) {
 		refreshToken: payload.refreshToken,
 		restaurantName: context.restaurantName,
 		city: context.city,
-		user: payload.user ? normalizeForgewayUser(payload.user) : void 0,
+		user: payload.user ? normalizeForgewayUser$1(payload.user) : void 0,
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	}, context.projectDir);
 	return payload.accessToken;
@@ -1922,25 +2003,33 @@ async function promptRequired(question, initialValue, deps, errorMessage) {
 async function readSavedForgewayMetadata(cwd) {
 	return await readForgewayDeployMetadata(cwd).catch(() => ({}));
 }
-async function resolveForgewayAccountEmail(options, grant, cwd, deps) {
-	const stored = await (deps.readCredentials ?? readForgewayCredentials)(cwd);
-	const storedEmail = stored?.source === "shadow-email-upgrade" && stored.placeId === grant.placeId && stored.user?.emailVerified === true && !isShadowEmail(stored.user?.email) ? stored.user?.email : void 0;
-	const suppliedEmail = options.email ?? getEnv("DINEWAY_EMAIL") ?? getEnv("FORGEWAY_EMAIL");
-	if ((options.sendOtp || options.otp) && !suppliedEmail) throw new Error("Forgeway OTP deploy requires --email or DINEWAY_EMAIL.");
-	const email = normalizeEmail(suppliedEmail ?? storedEmail ?? await promptRequired("Dineway account email: ", void 0, deps, "Dineway account email is required. Pass --email or set DINEWAY_EMAIL."));
-	if (!email || isShadowEmail(email)) throw new Error("Dineway account email must be a real owner email, not a shadow user email.");
+function explicitPublisherEmail(options) {
+	return options.email ?? getEnv("DINEWAY_EMAIL") ?? getEnv("FORGEWAY_EMAIL");
+}
+function savedPublisherEmail(saved) {
+	return typeof saved.publisherEmail === "string" && saved.publisherEmail.trim() ? saved.publisherEmail : void 0;
+}
+function validatePublisherEmail(rawEmail) {
+	const email = normalizeEmail$1(rawEmail);
+	if (!email || isShadowEmail$1(email)) throw new Error("Dineway account email must be a real owner email, not a shadow user email.");
 	return email;
 }
-function isStoredFormalCredentialForGrant(stored, grant, email) {
-	if (!stored?.accessToken || stored.source !== "shadow-email-upgrade" || stored.placeId !== grant.placeId || !stored.user) return false;
-	if (normalizeEmail(stored.user.email) !== email) return false;
+async function resolveForgewayAccountEmail(options, saved, deps, preferredEmail) {
+	const suppliedEmail = options.email ?? getEnv("DINEWAY_EMAIL") ?? getEnv("FORGEWAY_EMAIL");
+	const savedEmail = savedPublisherEmail(saved);
+	if ((options.sendOtp || options.otp) && !suppliedEmail && !preferredEmail && !savedEmail) throw new Error("Forgeway OTP deploy requires --email or DINEWAY_EMAIL.");
+	return validatePublisherEmail(suppliedEmail ?? preferredEmail ?? savedEmail ?? await promptRequired("Dineway account email: ", void 0, deps, "Dineway account email is required. Pass --email or set DINEWAY_EMAIL."));
+}
+function isStoredFormalCredentialForEmail(stored, email) {
+	if (!stored?.accessToken || !stored.user) return false;
+	if (email && normalizeEmail$1(stored.user.email) !== email) return false;
 	if (stored.user.emailVerified !== true) return false;
-	if (isShadowEmail(stored.user.email)) return false;
+	if (isShadowEmail$1(stored.user.email)) return false;
 	return true;
 }
 function assertVerifiedFormalAccountUser(user, expectedEmail) {
-	if (!user || user.emailVerified !== true || isShadowEmail(user.email)) throw new Error("Forgeway formal account credentials require a verified formal account.");
-	if (expectedEmail && normalizeEmail(user.email) !== normalizeEmail(expectedEmail)) throw new Error("Forgeway refresh returned credentials for a different email.");
+	if (!user || user.emailVerified !== true || isShadowEmail$1(user.email)) throw new Error("Forgeway formal account credentials require a verified formal account.");
+	if (expectedEmail && normalizeEmail$1(user.email) !== normalizeEmail$1(expectedEmail)) throw new Error("Forgeway refresh returned credentials for a different email.");
 	return user;
 }
 async function shadowUpgradeFetch(context, path, deps, options) {
@@ -1963,7 +2052,7 @@ async function startShadowEmailUpgrade(context, email, deps) {
 		method: "POST",
 		body: JSON.stringify({ email })
 	});
-	if (payload.email && normalizeEmail(payload.email) !== email) throw new Error("Forgeway email verification response returned a different email.");
+	if (payload.email && normalizeEmail$1(payload.email) !== email) throw new Error("Forgeway email verification response returned a different email.");
 	return payload;
 }
 async function verifyShadowEmailUpgrade(context, email, otp, deps) {
@@ -1975,21 +2064,24 @@ async function verifyShadowEmailUpgrade(context, email, otp, deps) {
 		})
 	});
 	if (!payload.accessToken || !payload.refreshToken || !payload.user) throw new Error("Forgeway email upgrade response was missing credentials.");
-	const user = normalizeForgewayUser(payload.user);
-	if (normalizeEmail(user.email) !== email) throw new Error("Forgeway email upgrade returned credentials for a different email.");
-	if (user.emailVerified !== true || isShadowEmail(user.email)) throw new Error("Forgeway email upgrade did not return a verified formal account.");
+	const user = normalizeForgewayUser$1(payload.user);
+	if (normalizeEmail$1(user.email) !== email) throw new Error("Forgeway email upgrade returned credentials for a different email.");
+	if (user.emailVerified !== true || isShadowEmail$1(user.email)) throw new Error("Forgeway email upgrade did not return a verified formal account.");
 	return {
 		platformApiUrl: context.platformApiUrl,
 		accessToken: payload.accessToken,
 		refreshToken: payload.refreshToken,
 		user,
-		source: "shadow-email-upgrade",
-		...context.placeId ? { placeId: context.placeId } : {}
+		source: "shadow-email-upgrade"
 	};
 }
-async function resolveFormalAccountCredentials(context, grant, email, options, deps) {
-	const stored = await (deps.readCredentials ?? readForgewayCredentials)(context.projectDir);
-	if (!options.sendOtp && !options.otp && isStoredFormalCredentialForGrant(stored, grant, email)) return {
+async function resolveFormalAccountCredentials(context, email, options, deps) {
+	const stored = await (deps.readCredentials ?? readForgewayCredentials)({
+		cwd: context.projectDir,
+		platformApiUrl: context.platformApiUrl,
+		email
+	});
+	if (!options.sendOtp && !options.otp && isStoredFormalCredentialForEmail(stored, email)) return {
 		status: "verified",
 		credentials: {
 			...stored,
@@ -2000,13 +2092,17 @@ async function resolveFormalAccountCredentials(context, grant, email, options, d
 		const response = await startShadowEmailUpgrade(context, email, deps);
 		return {
 			status: "otp-sent",
-			email: response.email ? normalizeEmail(response.email) : email,
+			email: response.email ? normalizeEmail$1(response.email) : email,
 			expiresAt: response.expiresAt
 		};
 	}
 	if (options.otp) {
 		const credentials = await verifyShadowEmailUpgrade(context, email, normalizeOtp(options.otp), deps);
-		await (deps.writeCredentials ?? writeForgewayCredentials)(credentials, context.projectDir);
+		await (deps.writeCredentials ?? writeForgewayCredentials)(credentials, {
+			cwd: context.projectDir,
+			platformApiUrl: context.platformApiUrl,
+			email
+		});
 		return {
 			status: "verified",
 			credentials
@@ -2015,13 +2111,111 @@ async function resolveFormalAccountCredentials(context, grant, email, options, d
 	await startShadowEmailUpgrade(context, email, deps);
 	consola.info(`Sent Forgeway email verification code to ${email}`);
 	const credentials = await verifyShadowEmailUpgrade(context, email, await promptRequired("Email verification code: ", void 0, deps, "Email verification code is required."), deps);
-	await (deps.writeCredentials ?? writeForgewayCredentials)(credentials, context.projectDir);
+	await (deps.writeCredentials ?? writeForgewayCredentials)(credentials, {
+		cwd: context.projectDir,
+		platformApiUrl: context.platformApiUrl,
+		email
+	});
 	return {
 		status: "verified",
 		credentials
 	};
 }
-async function resolveShadowProjectContext(cwd, options, deps) {
+async function readCachedPublisherCredentials(cwd, platformApiUrl, email, deps) {
+	const credentials = await (deps.readCredentials ?? readForgewayCredentials)({
+		cwd,
+		platformApiUrl,
+		email
+	});
+	return isStoredFormalCredentialForEmail(credentials, email) ? credentials : void 0;
+}
+async function resolveCachedPublisherAccount(cwd, options, saved, platformApiUrl, deps) {
+	const suppliedEmail = explicitPublisherEmail(options);
+	if (suppliedEmail) {
+		const email = validatePublisherEmail(suppliedEmail);
+		return {
+			email,
+			credentials: await readCachedPublisherCredentials(cwd, platformApiUrl, email, deps)
+		};
+	}
+	const projectEmail = savedPublisherEmail(saved);
+	if (projectEmail) {
+		const email = validatePublisherEmail(projectEmail);
+		return {
+			email,
+			credentials: await readCachedPublisherCredentials(cwd, platformApiUrl, email, deps)
+		};
+	}
+	const singleCredentials = await (deps.readCredentials ?? readForgewayCredentials)({
+		cwd,
+		platformApiUrl
+	});
+	if (isStoredFormalCredentialForEmail(singleCredentials)) return {
+		email: normalizeEmail$1(singleCredentials.user.email),
+		credentials: singleCredentials
+	};
+	const accounts = (await (deps.listCredentials ?? listForgewayCredentials)(platformApiUrl)).filter((credentials) => isStoredFormalCredentialForEmail(credentials));
+	if (accounts.length === 1) {
+		const credentials = accounts[0];
+		return {
+			email: normalizeEmail$1(credentials.user.email),
+			credentials
+		};
+	}
+	if (accounts.length > 1) {
+		const email = validatePublisherEmail(await promptRequired("Dineway account email: ", void 0, deps, "Multiple Dineway accounts are stored on this computer. Pass --email or set DINEWAY_EMAIL."));
+		return {
+			email,
+			credentials: await readCachedPublisherCredentials(cwd, platformApiUrl, email, deps)
+		};
+	}
+	return {};
+}
+async function resolveFormalProjectContext(cwd, options, deps) {
+	const saved = await readSavedForgewayMetadata(cwd);
+	const platformApiUrl = resolvePlatformApiUrl(saved.platformApiUrl);
+	const account = await resolveCachedPublisherAccount(cwd, options, saved, platformApiUrl, deps);
+	if (!account.credentials) return {
+		status: "missing",
+		email: account.email
+	};
+	const user = assertVerifiedFormalAccountUser(account.credentials.user, account.email);
+	const savedPlaceId = options.placeId ?? getEnv("DINEWAY_PLACE_ID") ?? (typeof saved.placeId === "string" ? saved.placeId : void 0);
+	if (savedPlaceId && !PLACE_ID_PATTERN.test(savedPlaceId)) throw new Error("Could not resolve a valid Dineway place id for Forgeway deploy.");
+	const context = {
+		projectDir: cwd,
+		platformApiUrl,
+		authKind: "formal-account",
+		accessToken: account.credentials.accessToken,
+		refreshToken: account.credentials.refreshToken,
+		user,
+		ossHost: platformApiUrl,
+		placeId: savedPlaceId,
+		restaurantName: options.restaurantName,
+		city: options.city
+	};
+	let restaurant = {
+		name: options.restaurantName,
+		city: options.city
+	};
+	if (!context.placeId) {
+		const resolvedRestaurant = await resolveShadowRestaurantInfo(options, deps);
+		restaurant = resolvedRestaurant;
+		context.placeId = await resolvePlaceIdWithFormalSearch({
+			context,
+			restaurant: resolvedRestaurant,
+			deps
+		});
+		context.restaurantName = resolvedRestaurant.name;
+		context.city = resolvedRestaurant.city;
+	}
+	return {
+		status: "ready",
+		context,
+		restaurant
+	};
+}
+async function resolveShadowProjectContext(cwd, options, deps, preferredEmail) {
 	const saved = await readSavedForgewayMetadata(cwd);
 	const platformApiUrl = resolvePlatformApiUrl(saved.platformApiUrl);
 	const savedPlaceId = options.placeId ?? getEnv("DINEWAY_PLACE_ID") ?? (typeof saved.placeId === "string" ? saved.placeId : void 0);
@@ -2077,8 +2271,7 @@ async function resolveShadowProjectContext(cwd, options, deps) {
 		restaurantName: restaurant.name,
 		city: restaurant.city
 	};
-	const accountEmail = await resolveForgewayAccountEmail(options, grant, cwd, deps);
-	const credentialsResult = await resolveFormalAccountCredentials(shadowContext, grant, accountEmail, options, deps);
+	const credentialsResult = await resolveFormalAccountCredentials(shadowContext, await resolveForgewayAccountEmail(options, saved, deps, preferredEmail), options, deps);
 	if (credentialsResult.status === "otp-sent") return credentialsResult;
 	const { credentials } = credentialsResult;
 	return {
@@ -2095,7 +2288,13 @@ async function resolveShadowProjectContext(cwd, options, deps) {
 	};
 }
 async function resolveProjectContext(cwd, options, deps) {
-	return await resolveShadowProjectContext(cwd, options, deps);
+	let preferredEmail;
+	if (!options.sendOtp && !options.otp) {
+		const formal = await resolveFormalProjectContext(cwd, options, deps);
+		if (formal.status !== "missing") return formal;
+		preferredEmail = formal.email;
+	}
+	return await resolveShadowProjectContext(cwd, options, deps, preferredEmail);
 }
 async function createShadowUser(platformApiUrl, placeId, deps) {
 	const response = await forgewayRequest(`${platformApiUrl}/api/auth/users/shadow`, {
@@ -2344,7 +2543,7 @@ async function bindShadowGrantPlace(options) {
 		refreshToken: payload.refreshToken ?? context.refreshToken ?? options.grant.refreshToken,
 		restaurantName: options.restaurant.name,
 		city: options.restaurant.city,
-		user: payload.user ? normalizeForgewayUser(payload.user) : context.user ?? options.grant.user
+		user: payload.user ? normalizeForgewayUser$1(payload.user) : context.user ?? options.grant.user
 	});
 	await (options.deps.writeShadowGrant ?? writeForgewayShadowGrant)(grant, options.cwd);
 	return grant;
@@ -2364,6 +2563,20 @@ async function resolvePlaceIdWithShadowSearch(options) {
 		placeId: finalPlaceId
 	});
 }
+async function resolvePlaceIdWithFormalSearch(options) {
+	const candidates = extractPlaceCandidates(await ossFetch(options.context, "/api/places/search", options.deps, {
+		method: "POST",
+		body: JSON.stringify({ textQuery: `${options.restaurant.name} in ${options.restaurant.city}` })
+	}));
+	if (candidates.length === 0) throw new Error(`Dineway place search returned no candidates for "${options.restaurant.name} in ${options.restaurant.city}".`);
+	const selected = selectPlaceCandidate(candidates, {
+		name: options.restaurant.name,
+		city: options.restaurant.city
+	});
+	const finalPlaceId = selected ? candidatePlaceId(selected.candidate) : "";
+	if (!PLACE_ID_PATTERN.test(finalPlaceId)) throw new Error("Could not resolve a valid Dineway place id for Forgeway deploy.");
+	return finalPlaceId;
+}
 async function createShadowGrant(options) {
 	if (options.placeId && !PLACE_ID_PATTERN.test(options.placeId)) throw new Error("Could not resolve a valid Dineway place id for Forgeway deploy.");
 	const auth = await createShadowUser(options.platformApiUrl, options.placeId, options.deps);
@@ -2374,14 +2587,14 @@ async function createShadowGrant(options) {
 		refreshToken: auth.refreshToken,
 		restaurantName: options.restaurantName,
 		city: options.city,
-		user: auth.user ? normalizeForgewayUser(auth.user) : void 0,
+		user: auth.user ? normalizeForgewayUser$1(auth.user) : void 0,
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	};
 	await (options.deps.writeShadowGrant ?? writeForgewayShadowGrant)(grant, options.cwd);
 	return grant;
 }
 async function ossFetch(context, path, deps, options = {}) {
-	const request = async (token) => await forgewayRequest(`${context.ossHost.replace(TRAILING_SLASH_PATTERN, "")}${path}`, {
+	const request = async (token) => await forgewayRequest(`${context.ossHost.replace(TRAILING_SLASH_PATTERN$1, "")}${path}`, {
 		...options,
 		headers: {
 			"Content-Type": "application/json",
@@ -2905,6 +3118,7 @@ async function deployForgeway(cwd, options, deps = {}) {
 		deps,
 		verbose
 	});
+	if (context.user?.email) await writeForgewayDeployMetadata(cwd, { publisherEmail: normalizeEmail$1(context.user.email) });
 	const url = deployment.liveUrl ?? `https://${site.domain}`;
 	await (deps.writeProjectEnv ?? persistForgewayCliEnv)(cwd, {
 		siteUrl: url,
@@ -3961,15 +4175,77 @@ async function exportSeed(db, withContent) {
 	};
 	seed.settings = await exportSettings(db);
 	seed.collections = await exportCollections(db);
-	seed.taxonomies = await exportTaxonomies(db);
-	seed.menus = await exportMenus(db);
+	const i18nEnabled = await detectI18nEnabled(db, seed.collections);
+	seed.taxonomies = await exportTaxonomies(db, i18nEnabled);
+	seed.menus = await exportMenus(db, i18nEnabled);
 	seed.widgetAreas = await exportWidgetAreas(db);
+	const { bylines, idToSeedId: bylineIdToSeedId } = await exportBylines(db);
+	if (bylines.length > 0) seed.bylines = bylines;
 	if (withContent !== void 0) {
 		const collections = withContent === "" || withContent === "true" ? null : withContent.split(",").map((s) => s.trim()).filter(Boolean);
-		seed.content = await exportContent(db, seed.collections || [], collections);
+		seed.content = await exportContent(db, seed.collections || [], collections, bylineIdToSeedId, i18nEnabled);
 	}
 	return seed;
 }
+async function exportBylines(db) {
+	const bylineRepo = new BylineRepository(db);
+	const bylines = [];
+	const idToSeedId = /* @__PURE__ */ new Map();
+	let cursor;
+	do {
+		const result = await bylineRepo.findMany({
+			limit: 100,
+			cursor
+		});
+		for (const byline of result.items) {
+			const seedId = `byline:${byline.slug}`;
+			idToSeedId.set(byline.id, seedId);
+			bylines.push({
+				id: seedId,
+				slug: byline.slug,
+				displayName: byline.displayName,
+				bio: byline.bio || void 0,
+				websiteUrl: byline.websiteUrl || void 0,
+				isGuest: byline.isGuest || void 0
+			});
+		}
+		cursor = result.nextCursor;
+	} while (cursor);
+	return {
+		bylines,
+		idToSeedId
+	};
+}
+/**
+* Determine whether export should preserve locale-suffixed seed ids.
+*
+* Runtime i18n config is initialized by middleware, but `dineway export-seed`
+* runs in a CLI process. When the runtime flag is unset, derive multi-locale
+* status from stored rows instead: a project is multi-locale when any
+* i18n-aware table contains more than one distinct locale.
+*/
+async function detectI18nEnabled(db, collections) {
+	if (isI18nEnabled()) return true;
+	const locales = /* @__PURE__ */ new Set();
+	const collectDistinctLocales = async (tableRef) => {
+		const result = await sql`
+			SELECT DISTINCT locale FROM ${tableRef}
+		`.execute(db);
+		for (const row of result.rows) if (row.locale) locales.add(row.locale);
+		return locales.size > 1;
+	};
+	if (await collectDistinctLocales(sql.ref("_dineway_taxonomy_defs"))) return true;
+	if (await collectDistinctLocales(sql.ref("_dineway_menus"))) return true;
+	for (const collection of collections) {
+		validateIdentifier(collection.slug, "collection slug");
+		try {
+			if (await collectDistinctLocales(sql.ref(`ec_${collection.slug}`))) return true;
+		} catch (error) {
+			if (!isMissingTableError(error)) throw error;
+		}
+	}
+	return false;
+}
 /**
 * Export site settings
 */
@@ -4019,8 +4295,7 @@ async function exportCollections(db) {
 /**
 * Export taxonomy definitions and terms
 */
-async function exportTaxonomies(db) {
-	const i18nEnabled = isI18nEnabled();
+async function exportTaxonomies(db, i18nEnabled) {
 	const defs = await db.selectFrom("_dineway_taxonomy_defs").selectAll().orderBy(["name", "locale"]).execute();
 	const result = [];
 	const termRepo = new TaxonomyRepository(db);
@@ -4077,8 +4352,7 @@ async function exportTaxonomies(db) {
 /**
 * Export menus with their items
 */
-async function exportMenus(db) {
-	const i18nEnabled = isI18nEnabled();
+async function exportMenus(db, i18nEnabled) {
 	const menus = await db.selectFrom("_dineway_menus").selectAll().orderBy(["name", "locale"]).execute();
 	const result = [];
 	const groupToSeedId = /* @__PURE__ */ new Map();
@@ -4200,11 +4474,12 @@ async function exportWidgetAreas(db) {
 /**
 * Export content from collections
 */
-async function exportContent(db, collections, includeCollections) {
+async function exportContent(db, collections, includeCollections, bylineIdToSeedId, i18nEnabled) {
 	const content = {};
 	const contentRepo = new ContentRepository(db);
 	const taxonomyRepo = new TaxonomyRepository(db);
 	const mediaRepo = new MediaRepository(db);
+	const bylineRepo = new BylineRepository(db);
 	const mediaMap = /* @__PURE__ */ new Map();
 	try {
 		let cursor;
@@ -4223,7 +4498,6 @@ async function exportContent(db, collections, includeCollections) {
 			cursor = result.nextCursor;
 		} while (cursor);
 	} catch {}
-	const i18nEnabled = isI18nEnabled();
 	for (const collection of collections) {
 		if (includeCollections && !includeCollections.includes(collection.slug)) continue;
 		const entries = [];
@@ -4253,6 +4527,8 @@ async function exportContent(db, collections, includeCollections) {
 				}
 				const taxonomies = await getTaxonomyAssignments(taxonomyRepo, collection.slug, item.id);
 				if (Object.keys(taxonomies).length > 0) entry.taxonomies = taxonomies;
+				const bylines = await getBylineCredits(bylineRepo, collection.slug, item.id, bylineIdToSeedId);
+				if (bylines.length > 0) entry.bylines = bylines;
 				entries.push(entry);
 			}
 			cursor = result.nextCursor;
@@ -4299,6 +4575,15 @@ function processDataForExport(data, fields, mediaMap) {
 	}
 	return result;
 }
+async function getBylineCredits(bylineRepo, collection, entryId, bylineIdToSeedId) {
+	return (await bylineRepo.getContentBylines(collection, entryId)).flatMap((credit) => {
+		const seedId = bylineIdToSeedId.get(credit.byline.id);
+		if (!seedId) return [];
+		const seedCredit = { byline: seedId };
+		if (credit.roleLabel) seedCredit.roleLabel = credit.roleLabel;
+		return [seedCredit];
+	});
+}
 /**
 * Get taxonomy term assignments for a content entry
 */
@@ -4977,6 +5262,9 @@ const MAX_SCREENSHOTS = 5;
 const MAX_SCREENSHOT_WIDTH = 1920;
 const MAX_SCREENSHOT_HEIGHT = 1080;
 const ICON_SIZE = 256;
+function toFileImportSpecifier(filePath) {
+	return pathToFileURL(filePath).href;
+}
 /** Matches Node.js built-in imports in bundled output. */
 const NODE_BUILTIN_IMPORT_RE = /(?:import|export|require)\s*(?:\(|[^(]*?\bfrom\s+)["'](?:node:)?([a-z_]+)(?:\/[^"']*)?\s*["']\)?/g;
 const LEADING_DOT_SLASH_RE = /^\.\//;
@@ -5303,7 +5591,7 @@ const bundleCommand = defineCommand({
 				consola.error("Failed to build main entry — no output found in", mainOutDir);
 				process.exit(1);
 			}
-			const pluginModule = await import(mainOutputPath);
+			const pluginModule = await import(toFileImportSpecifier(mainOutputPath));
 			let resolvedPlugin;
 			if (typeof pluginModule.createPlugin === "function") resolvedPlugin = pluginModule.createPlugin();
 			else if (typeof pluginModule.default === "function") resolvedPlugin = pluginModule.default();
@@ -5347,7 +5635,7 @@ const bundleCommand = defineCommand({
 							});
 							const backendProbePath = await findBuildOutput(backendProbeDir, basename(backendEntry).replace(TS_EXT_RE, ""));
 							if (backendProbePath) {
-								const standardDef = (await import(backendProbePath)).default ?? {};
+								const standardDef = (await import(toFileImportSpecifier(backendProbePath))).default ?? {};
 								const hooks = standardDef.hooks;
 								const routes = standardDef.routes;
 								if (hooks) for (const hookName of Object.keys(hooks)) {
@@ -6858,6 +7146,586 @@ const seedCommand = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/cli/forgeway-seo-client.ts
+const DEFAULT_DINEWAY_API_BASE_URL = "https://api.dineway.ai";
+const TRAILING_SLASH_PATTERN = /\/$/;
+const SHADOW_EMAIL_PATTERN = /^shadow_[a-f0-9]{16}@dineway\.ai$/i;
+var ForgewaySeoApiError = class extends Error {
+	constructor(message, status, body) {
+		super(message);
+		this.status = status;
+		this.body = body;
+		this.name = "ForgewaySeoApiError";
+	}
+};
+function normalizeApiUrl(value) {
+	return (value || DEFAULT_DINEWAY_API_BASE_URL).replace(TRAILING_SLASH_PATTERN, "");
+}
+function resolveForgewaySeoApiUrl(savedPlatformApiUrl, cwd = process.cwd()) {
+	return normalizeApiUrl(getProjectEnvValue("DINEWAY_API_BASE_URL", cwd) ?? (typeof savedPlatformApiUrl === "string" ? savedPlatformApiUrl : void 0));
+}
+function normalizeEmail(value) {
+	return value?.trim().toLowerCase() ?? "";
+}
+function isShadowEmail(email) {
+	return Boolean(email && SHADOW_EMAIL_PATTERN.test(email));
+}
+function assertFormalUser(user) {
+	if (!user || user.emailVerified !== true || isShadowEmail(user.email)) throw new Error("Forgeway SEO provider access requires verified formal Forgeway credentials. Run `dineway deploy forgeway` and complete email verification first.");
+	return user;
+}
+function normalizeForgewayUser(user, fallback) {
+	if (!user?.id || !user.email) return fallback;
+	return {
+		id: user.id,
+		name: user.profile?.name ?? user.name ?? user.email,
+		email: user.email,
+		avatarUrl: user.profile?.avatar_url ?? user.avatarUrl ?? user.avatar_url ?? null,
+		emailVerified: user.emailVerified ?? user.email_verified ?? false
+	};
+}
+async function parseJsonResponse(response) {
+	const text = await response.text();
+	if (!text) return {};
+	try {
+		return JSON.parse(text);
+	} catch {
+		return { message: text };
+	}
+}
+function errorMessage(body, fallback) {
+	if (typeof body !== "object" || body === null) return fallback;
+	const record = body;
+	if (typeof record.message === "string") return record.message;
+	if (typeof record.error === "string") return record.error;
+	const nestedError = record.error;
+	if (typeof nestedError === "object" && nestedError !== null) {
+		const message = nestedError.message;
+		if (typeof message === "string") return message;
+	}
+	return fallback;
+}
+var ForgewaySeoGatewayClient = class {
+	fetchImpl;
+	readCredentials;
+	writeCredentials;
+	cwd;
+	constructor(deps = {}) {
+		this.fetchImpl = deps.fetch ?? fetch;
+		this.readCredentials = deps.readCredentials ?? readForgewayCredentials;
+		this.writeCredentials = deps.writeCredentials ?? writeForgewayCredentials;
+		this.cwd = deps.cwd ?? process.cwd();
+	}
+	async loadCredentials() {
+		const metadata = await readForgewayDeployMetadata(this.cwd).catch(() => ({}));
+		const platformApiUrl = resolveForgewaySeoApiUrl(metadata.platformApiUrl, this.cwd);
+		const credentials = await this.readCredentials({
+			cwd: this.cwd,
+			platformApiUrl,
+			email: typeof metadata.publisherEmail === "string" ? metadata.publisherEmail : void 0
+		});
+		if (!credentials?.accessToken) throw new Error("Forgeway SEO provider access requires stored Forgeway credentials. Run `dineway deploy forgeway` first.");
+		assertFormalUser(credentials.user);
+		if (!credentials.refreshToken) throw new Error("Forgeway SEO provider access requires a stored formal-account refresh token. Run `dineway deploy forgeway` again.");
+		return {
+			...credentials,
+			platformApiUrl: resolveForgewaySeoApiUrl(credentials.platformApiUrl, this.cwd)
+		};
+	}
+	async refreshAccessToken(credentials) {
+		const response = await this.fetchImpl(`${credentials.platformApiUrl}/api/auth/refresh?client_type=server`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ refreshToken: credentials.refreshToken })
+		});
+		const body = await parseJsonResponse(response);
+		if (!response.ok) throw new ForgewaySeoApiError(errorMessage(body, "Failed to refresh Forgeway formal account credentials. Run `dineway deploy forgeway` again."), response.status, body);
+		if (!body.accessToken) throw new Error("Forgeway refresh response was missing accessToken.");
+		const user = assertFormalUser(normalizeForgewayUser(body.user, credentials.user));
+		if (credentials.user?.email && normalizeEmail(user.email) !== normalizeEmail(credentials.user.email)) throw new Error("Forgeway refresh returned credentials for a different email.");
+		const updated = {
+			...credentials,
+			accessToken: body.accessToken,
+			refreshToken: body.refreshToken ?? credentials.refreshToken,
+			user
+		};
+		await this.writeCredentials(updated, {
+			cwd: this.cwd,
+			platformApiUrl: updated.platformApiUrl,
+			email: user.email
+		});
+		return updated;
+	}
+	async request(path, body, init) {
+		const credentials = await this.refreshAccessToken(await this.loadCredentials());
+		const response = await this.fetchImpl(`${credentials.platformApiUrl}${path}`, {
+			method: init?.method ?? "POST",
+			headers: {
+				Authorization: `Bearer ${credentials.accessToken}`,
+				"Content-Type": "application/json"
+			},
+			body: init?.method === "GET" ? void 0 : JSON.stringify(body ?? {})
+		});
+		const payload = await parseJsonResponse(response);
+		if (!response.ok) throw new ForgewaySeoApiError(errorMessage(payload, `Forgeway SEO request failed with status ${response.status}.`), response.status, payload);
+		return payload;
+	}
+};
+
+//#endregion
+//#region src/cli/commands/seo.ts
+const hostedProviderArgs = {
+	json: {
+		type: "boolean",
+		description: "Output as JSON"
+	},
+	"force-refresh": {
+		type: "boolean",
+		description: "Bypass Forgeway SEO provider cache"
+	}
+};
+const dataForSeoCommonArgs = {
+	...hostedProviderArgs,
+	"location-code": {
+		type: "string",
+		description: "DataForSEO location code",
+		default: "2840"
+	},
+	"language-code": {
+		type: "string",
+		description: "DataForSEO language code",
+		default: "en"
+	},
+	device: {
+		type: "string",
+		description: "Device type: desktop or mobile",
+		default: "desktop"
+	}
+};
+function toStringValue(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function toNumberValue(value, fallback) {
+	const raw = toStringValue(value);
+	if (!raw) return fallback;
+	const parsed = Number(raw);
+	return Number.isFinite(parsed) ? parsed : fallback;
+}
+function forceRefresh(args) {
+	return args["force-refresh"] === true;
+}
+function formats(value) {
+	const raw = toStringValue(value);
+	if (!raw) return void 0;
+	return raw.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function requireArg(value, name) {
+	const normalized = toStringValue(value);
+	if (!normalized) throw new Error(`${name} is required.`);
+	return normalized;
+}
+async function runSeoRequest(args, path, body) {
+	configureOutputMode(args);
+	try {
+		output(await new ForgewaySeoGatewayClient().request(path, body), args);
+	} catch (error) {
+		consola$1.error(error instanceof Error ? error.message : "Unknown error");
+		process.exit(1);
+	}
+}
+const firecrawlCommand = defineCommand({
+	meta: {
+		name: "firecrawl",
+		description: "Forgeway-hosted Firecrawl workflows"
+	},
+	subCommands: {
+		scrape: defineCommand({
+			meta: {
+				name: "scrape",
+				description: "Scrape one URL through Forgeway-hosted Firecrawl"
+			},
+			args: {
+				url: {
+					type: "positional",
+					description: "URL to scrape",
+					required: true
+				},
+				...hostedProviderArgs,
+				formats: {
+					type: "string",
+					description: "Comma-separated Firecrawl formats",
+					default: "markdown"
+				},
+				"only-main-content": {
+					type: "boolean",
+					description: "Return main content only",
+					default: true
+				},
+				"timeout-ms": {
+					type: "string",
+					description: "Provider timeout in milliseconds",
+					default: "60000"
+				}
+			},
+			async run({ args }) {
+				await runSeoRequest(args, "/api/firecrawl/scrape", {
+					url: requireArg(args.url, "url"),
+					formats: formats(args.formats),
+					onlyMainContent: args["only-main-content"] !== false,
+					timeoutMs: toNumberValue(args["timeout-ms"], 6e4),
+					forceRefresh: forceRefresh(args)
+				});
+			}
+		}),
+		map: defineCommand({
+			meta: {
+				name: "map",
+				description: "Map URLs through Forgeway-hosted Firecrawl"
+			},
+			args: {
+				url: {
+					type: "positional",
+					description: "Base URL to map",
+					required: true
+				},
+				...hostedProviderArgs,
+				search: {
+					type: "string",
+					description: "Optional relevance search term"
+				},
+				sitemap: {
+					type: "string",
+					description: "Sitemap mode: skip, include, or only",
+					default: "include"
+				},
+				limit: {
+					type: "string",
+					description: "Maximum URLs",
+					default: "100"
+				},
+				"include-subdomains": {
+					type: "boolean",
+					description: "Include subdomains"
+				},
+				"ignore-query-parameters": {
+					type: "boolean",
+					description: "Ignore query parameters",
+					default: true
+				}
+			},
+			async run({ args }) {
+				await runSeoRequest(args, "/api/firecrawl/map", {
+					url: requireArg(args.url, "url"),
+					search: toStringValue(args.search),
+					sitemap: toStringValue(args.sitemap) ?? "include",
+					limit: toNumberValue(args.limit, 100),
+					includeSubdomains: args["include-subdomains"] === true,
+					ignoreQueryParameters: args["ignore-query-parameters"] !== false,
+					forceRefresh: forceRefresh(args)
+				});
+			}
+		}),
+		crawl: defineCommand({
+			meta: {
+				name: "crawl",
+				description: "Start a bounded Firecrawl crawl, or check status with --id"
+			},
+			args: {
+				url: {
+					type: "positional",
+					description: "Base URL to crawl"
+				},
+				...hostedProviderArgs,
+				id: {
+					type: "string",
+					description: "Existing Firecrawl crawl id to check"
+				},
+				limit: {
+					type: "string",
+					description: "Maximum pages",
+					default: "25"
+				},
+				"max-depth": {
+					type: "string",
+					description: "Maximum discovery depth",
+					default: "3"
+				},
+				"allow-subdomains": {
+					type: "boolean",
+					description: "Allow subdomains"
+				},
+				"allow-external-links": {
+					type: "boolean",
+					description: "Allow external links"
+				},
+				formats: {
+					type: "string",
+					description: "Comma-separated scrape formats",
+					default: "markdown"
+				}
+			},
+			async run({ args }) {
+				const crawlId = toStringValue(args.id);
+				if (crawlId) {
+					configureOutputMode(args);
+					try {
+						output(await new ForgewaySeoGatewayClient().request(`/api/firecrawl/crawl/${encodeURIComponent(crawlId)}`, void 0, { method: "GET" }), args);
+					} catch (error) {
+						consola$1.error(error instanceof Error ? error.message : "Unknown error");
+						process.exit(1);
+					}
+					return;
+				}
+				await runSeoRequest(args, "/api/firecrawl/crawl", {
+					url: requireArg(args.url, "url"),
+					limit: toNumberValue(args.limit, 25),
+					maxDiscoveryDepth: toNumberValue(args["max-depth"], 3),
+					allowExternalLinks: args["allow-external-links"] === true,
+					allowSubdomains: args["allow-subdomains"] === true,
+					scrapeFormats: formats(args.formats),
+					forceRefresh: forceRefresh(args)
+				});
+			}
+		}),
+		search: defineCommand({
+			meta: {
+				name: "search",
+				description: "Search through Forgeway-hosted Firecrawl"
+			},
+			args: {
+				query: {
+					type: "positional",
+					description: "Search query",
+					required: true
+				},
+				...hostedProviderArgs,
+				limit: {
+					type: "string",
+					description: "Maximum results",
+					default: "10"
+				},
+				scrape: {
+					type: "boolean",
+					description: "Scrape result markdown"
+				}
+			},
+			async run({ args }) {
+				await runSeoRequest(args, "/api/firecrawl/search", {
+					query: requireArg(args.query, "query"),
+					limit: toNumberValue(args.limit, 10),
+					scrape: args.scrape === true,
+					forceRefresh: forceRefresh(args)
+				});
+			}
+		})
+	}
+});
+function dataForSeoBase(args) {
+	return {
+		locationCode: toNumberValue(args["location-code"], 2840),
+		languageCode: toStringValue(args["language-code"]) ?? "en",
+		device: toStringValue(args.device) ?? "desktop",
+		forceRefresh: forceRefresh(args)
+	};
+}
+const dataForSeoSerpCommand = defineCommand({
+	meta: {
+		name: "serp",
+		description: "Fetch Google organic SERP data"
+	},
+	args: {
+		keyword: {
+			type: "positional",
+			description: "Keyword",
+			required: true
+		},
+		...dataForSeoCommonArgs,
+		depth: {
+			type: "string",
+			description: "SERP depth",
+			default: "10"
+		}
+	},
+	async run({ args }) {
+		await runSeoRequest(args, "/api/dataforseo/serp", {
+			keyword: requireArg(args.keyword, "keyword"),
+			depth: toNumberValue(args.depth, 10),
+			...dataForSeoBase(args)
+		});
+	}
+});
+const dataForSeoMapsCommand = defineCommand({
+	meta: {
+		name: "maps",
+		description: "Fetch Google Maps SERP data"
+	},
+	args: {
+		keyword: {
+			type: "positional",
+			description: "Keyword",
+			required: true
+		},
+		...dataForSeoCommonArgs,
+		depth: {
+			type: "string",
+			description: "Maps depth",
+			default: "10"
+		}
+	},
+	async run({ args }) {
+		await runSeoRequest(args, "/api/dataforseo/maps", {
+			keyword: requireArg(args.keyword, "keyword"),
+			depth: toNumberValue(args.depth, 10),
+			...dataForSeoBase(args)
+		});
+	}
+});
+const dataForSeoKeywordsCommand = defineCommand({
+	meta: {
+		name: "keywords",
+		description: "Fetch keyword suggestions"
+	},
+	args: {
+		keyword: {
+			type: "positional",
+			description: "Seed keyword",
+			required: true
+		},
+		...dataForSeoCommonArgs,
+		limit: {
+			type: "string",
+			description: "Maximum suggestions",
+			default: "20"
+		}
+	},
+	async run({ args }) {
+		await runSeoRequest(args, "/api/dataforseo/keywords", {
+			keyword: requireArg(args.keyword, "keyword"),
+			limit: toNumberValue(args.limit, 20),
+			includeSerpInfo: true,
+			includeSeedKeyword: true,
+			...dataForSeoBase(args)
+		});
+	}
+});
+const dataForSeoCompetitorsCommand = defineCommand({
+	meta: {
+		name: "competitors",
+		description: "Fetch competitor-domain data"
+	},
+	args: {
+		domain: {
+			type: "positional",
+			description: "Target domain",
+			required: true
+		},
+		...dataForSeoCommonArgs,
+		limit: {
+			type: "string",
+			description: "Maximum competitors",
+			default: "20"
+		}
+	},
+	async run({ args }) {
+		await runSeoRequest(args, "/api/dataforseo/competitors", {
+			targetDomain: requireArg(args.domain, "domain"),
+			limit: toNumberValue(args.limit, 20),
+			...dataForSeoBase(args)
+		});
+	}
+});
+const dataForSeoAiScrapeCommand = defineCommand({
+	meta: {
+		name: "ai-scrape",
+		description: "Fetch DataForSEO AI scraper response data"
+	},
+	args: {
+		keyword: {
+			type: "positional",
+			description: "AI search keyword",
+			required: true
+		},
+		...dataForSeoCommonArgs,
+		platform: {
+			type: "string",
+			description: "AI platform: chat_gpt, gemini, or perplexity",
+			default: "chat_gpt"
+		}
+	},
+	async run({ args }) {
+		await runSeoRequest(args, "/api/dataforseo/ai-scrape", {
+			keyword: requireArg(args.keyword, "keyword"),
+			platform: toStringValue(args.platform) ?? "chat_gpt",
+			...dataForSeoBase(args)
+		});
+	}
+});
+const dataForSeoAiMentionsCommand = defineCommand({
+	meta: {
+		name: "ai-mentions",
+		description: "Fetch DataForSEO LLM mention data"
+	},
+	args: {
+		...dataForSeoCommonArgs,
+		domain: {
+			type: "string",
+			description: "Target domain"
+		},
+		keyword: {
+			type: "string",
+			description: "Target keyword"
+		},
+		platform: {
+			type: "string",
+			description: "Mention platform: google or chat_gpt",
+			default: "google"
+		},
+		limit: {
+			type: "string",
+			description: "Maximum mentions",
+			default: "20"
+		}
+	},
+	async run({ args }) {
+		if (!toStringValue(args.domain) && !toStringValue(args.keyword)) {
+			consola$1.error("domain or keyword is required.");
+			process.exit(1);
+		}
+		await runSeoRequest(args, "/api/dataforseo/ai-mentions", {
+			targetDomain: toStringValue(args.domain),
+			keyword: toStringValue(args.keyword),
+			platform: toStringValue(args.platform) ?? "google",
+			limit: toNumberValue(args.limit, 20),
+			...dataForSeoBase(args)
+		});
+	}
+});
+const dataForSeoCommand = defineCommand({
+	meta: {
+		name: "dataforseo",
+		description: "Forgeway-hosted DataForSEO workflows"
+	},
+	subCommands: {
+		serp: dataForSeoSerpCommand,
+		maps: dataForSeoMapsCommand,
+		keywords: dataForSeoKeywordsCommand,
+		competitors: dataForSeoCompetitorsCommand,
+		"ai-scrape": dataForSeoAiScrapeCommand,
+		"ai-mentions": dataForSeoAiMentionsCommand
+	}
+});
+const seoCommand = defineCommand({
+	meta: {
+		name: "seo",
+		description: "Hosted SEO provider workflows through Forgeway"
+	},
+	subCommands: {
+		firecrawl: firecrawlCommand,
+		dataforseo: dataForSeoCommand
+	}
+});
+
 //#endregion
 //#region src/cli/commands/taxonomy.ts
 /**
@@ -7074,6 +7942,7 @@ runMain(defineCommand({
 		schema: schemaCommand,
 		media: mediaCommand,
 		search: searchCommand,
+		seo: seoCommand,
 		taxonomy: taxonomyCommand,
 		menu: menuCommand,
 		plugin: pluginCommand