@tailor-platform/sdk 1.76.2 → 1.79.0

package/dist/{runtime-DlklyuHN.mjs → runtime-CjMeYuPA.mjs}

@@ -1,9 +1,9 @@
-import { t as db } from "./schema-DbTR1c6M.mjs";
+import { t as db } from "./schema-CYrle8JZ.mjs";
 import { $ as CreateAuthIDPConfigRequestSchema, A as CreatePipelineResolverRequestSchema, At as TenantProviderConfig_TenantProviderType, B as IdPPermissionOperator, Bt as CreateAIGatewayRequestSchema, C as UpdateStaticWebsiteRequestSchema, Ct as AuthOAuth2Client_ClientType, D as CreateSecretManagerVaultRequestSchema, Dt as AuthSCIMAttribute_Uniqueness, E as CreateSecretManagerSecretRequestSchema, Et as AuthSCIMAttribute_Type, F as PipelineResolver_OperationType, Ft as GetApplicationSchemaHealthResponse_ApplicationSchemaHealthStatus, G as CreateExecutorExecutorRequestSchema, Gt as ConditionSchema, H as FunctionExecution_Status, I as CreateIdPServiceRequestSchema, It as UpdateApplicationRequestSchema, J as ExecutorJobStatus, Jt as PageDirection, K as UpdateExecutorExecutorRequestSchema, Kt as Condition_Operator, L as UpdateIdPServiceRequestSchema, M as UpdatePipelineResolverRequestSchema, N as UpdatePipelineServiceRequestSchema, O as UpdateSecretManagerSecretRequestSchema, Ot as AuthSCIMConfig_AuthorizationType, Pt as CreateApplicationRequestSchema, Q as CreateAuthHookRequestSchema, Rt as ApplicationSchemaUpdateAttemptStatus, S as CreateStaticWebsiteRequestSchema, St as AuthInvokerSchema, Tt as AuthSCIMAttribute_Mutability, V as IdPPermissionPermit, Vt as UpdateAIGatewayRequestSchema, X as ExecutorTriggerType, Y as ExecutorTargetType, Z as CreateAuthConnectionRequestSchema, _ as TailorDBGQLPermission_Permit, a as CreateWorkflowRequestSchema, at as CreateTenantConfigRequestSchema, b as TailorDBType_PermitAction, bt as AuthHookPoint, ct as UpdateAuthHookRequestSchema, d as CreateTailorDBServiceRequestSchema, dt as UpdateAuthOAuth2ClientRequestSchema, et as CreateAuthMachineUserRequestSchema, f as CreateTailorDBTypeRequestSchema, ft as UpdateAuthSCIMConfigRequestSchema, g as TailorDBGQLPermission_Operator, gt as UpdateUserProfileConfigRequestSchema, h as TailorDBGQLPermission_Action, ht as UpdateTenantConfigRequestSchema, i as CreateWorkflowJobFunctionRequestSchema, it as CreateAuthServiceRequestSchema, j as CreatePipelineServiceRequestSchema, jt as UserProfileProviderConfig_UserProfileProviderType, l as WorkflowExecution_Status, lt as UpdateAuthIDPConfigRequestSchema, mt as UpdateAuthServiceRequestSchema, nt as CreateAuthSCIMConfigRequestSchema, o as UpdateWorkflowJobFunctionExecutionPolicyRequestSchema, ot as CreateUserProfileConfigRequestSchema, p as UpdateTailorDBTypeRequestSchema, pt as UpdateAuthSCIMResourceRequestSchema, qt as FilterSchema, r as CreateWorkflowJobFunctionExecutionPolicyRequestSchema, rt as CreateAuthSCIMResourceRequestSchema, s as UpdateWorkflowRequestSchema, st as UpdateAuthConnectionRequestSchema, t as WorkspacePlatformUserRole, tt as CreateAuthOAuth2ClientRequestSchema, u as WorkflowJobExecution_Status, ut as UpdateAuthMachineUserRequestSchema, v as TailorDBType_Permission_Operator, vt as AuthConnection_Status, wt as AuthOAuth2Client_GrantType, x as AddCustomDomainRequestSchema, xt as AuthIDPConfig_AuthType, y as TailorDBType_Permission_Permit, yt as AuthConnection_Type, z as IdPLang, zt as Subgraph_ServiceType } from "./workspace_resource_pb-Db3fv68L.mjs";
 import { t as assertDefined } from "./assert-DBxo8jPo.mjs";
-import { a as parseBoolean, i as symbols, n as logger, r as styles, t as CIPromptError } from "./logger-BEiZZ3qT.mjs";
-import { A as fetchAllTolerant, B as initOperatorClient, C as createBundleCache, E as hashFile, F as getConsoleBaseUrl, G as byName, H as normalizeBaseUrl, I as getOAuth2ClientId, K as LOG_LEVELS, L as getOrNull, M as fetchPaged, O as defaultPlatformBaseUrl, R as getPlatformBaseUrl, S as hasGenerationHooks, T as hashContent, U as rememberPlatformConfigForToken, V as isDefaultPlatform, W as resolveStaticWebsiteUrls, _ as platformBundleDefinePlugin, d as buildExecutorArgsExpr, f as buildResolverOperationHookExpr, g as stringifyFunction, h as TailorDBTypeSchema, i as resolverBundleKey, j as fetchMachineUserToken, k as fetchAll, l as HTTP_METHODS, m as assertUniqueTailorDBTypeNamesWithExternal, n as generatePluginFilesIfNeeded, o as WorkflowJobFunctionExecutionPolicySchema, p as assertUniqueLocalTailorDBTypeNames, r as loadApplication, t as defineApplication, w as getDistDir, x as getPluginGenerationDependencies, z as initOAuth2Client } from "./application-CqjCcZ2n.mjs";
-import { o as loadFilesWithIgnores, s as functionSchema, t as createExecutorService } from "./service-BCRJ-3NV.mjs";
+import { a as parseBoolean, i as symbols, n as logger, r as styles, t as CIPromptError } from "./logger-BwS4ppwO.mjs";
+import { A as fetchAllTolerant, B as initOperatorClient, C as createBundleCache, E as hashFile, F as getConsoleBaseUrl, G as byName, H as normalizeBaseUrl, I as getOAuth2ClientId, K as LOG_LEVELS, L as getOrNull, M as fetchPaged, O as defaultPlatformBaseUrl, R as getPlatformBaseUrl, S as hasGenerationHooks, T as hashContent, U as rememberPlatformConfigForToken, V as isDefaultPlatform, W as resolveStaticWebsiteUrls, _ as platformBundleDefinePlugin, d as buildExecutorArgsExpr, f as buildResolverOperationHookExpr, g as stringifyFunction, h as TailorDBTypeSchema, i as resolverBundleKey, j as fetchMachineUserToken, k as fetchAll, l as HTTP_METHODS, m as assertUniqueTailorDBTypeNamesWithExternal, n as generatePluginFilesIfNeeded, o as WorkflowJobFunctionExecutionPolicySchema, p as assertUniqueLocalTailorDBTypeNames, r as loadApplication, t as defineApplication, w as getDistDir, x as getPluginGenerationDependencies, z as initOAuth2Client } from "./application-fjqb-Gh8.mjs";
+import { o as loadFilesWithIgnores, s as functionSchema, t as createExecutorService } from "./service-D12iQGcS.mjs";
 import { n as enumConstantsPlugin, t as EnumConstantsGeneratorID } from "./enum-constants-j9QBF0cB.mjs";
 import { t as multiline } from "./multiline-sfHpTZZK.mjs";
 import { n as fileUtilsPlugin, t as FileUtilsGeneratorID } from "./file-utils-DcyIPFQh.mjs";
@@ -11,7 +11,7 @@ import { n as kyselyTypePlugin, t as KyselyGeneratorID } from "./kysely-type-D-z
 import { n as seedPlugin, t as SeedGeneratorID } from "./seed-DFFigL8V.mjs";
 import { t as readPackageJson } from "./package-json-8b0O9TlX.mjs";
 import { t as userAgent } from "./user-agent-DX2Jnw0-.mjs";
-import { n as isCLIError, t as createCLIError } from "./errors-Dtf2WPaW.mjs";
+import { r as isCLIError, t as createCLIError } from "./errors-DVFS0AZk.mjs";
 import { n as tightenSecretFilePermissions, r as writeSecretFile } from "./secret-file-DBqZhjFQ.mjs";
 import { r as withSpan } from "./telemetry-CdqJEzkj.mjs";
 import { arg, createDefineCommand, defineCommand, runCommand } from "politty";
@@ -22,6 +22,7 @@ import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { parseEnv } from "node:util";
 import { ValueSchema, timestampDate } from "@bufbuild/protobuf/wkt";
 import * as path from "pathe";
+import { basename, dirname, join, resolve } from "pathe";
 import { formatDistanceToNowStrict } from "date-fns";
 import { getBorderCharacters, table } from "table";
 import { pathToFileURL } from "node:url";
@@ -35,13 +36,13 @@ import { Code, ConnectError } from "@connectrpc/connect";
 import pLimit from "p-limit";
 import { resolveTSConfig } from "pkg-types";
 import * as crypto$1 from "node:crypto";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { ExitPromptError } from "@inquirer/core";
-import { confirm, input, password } from "@inquirer/prompts";
+import { confirm, input, password, select } from "@inquirer/prompts";
 import { isCI } from "std-env";
 import * as rolldown from "rolldown";
 import * as fs from "node:fs/promises";
-import { glob } from "node:fs/promises";
+import { glob, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { parseSync } from "oxc-parser";
 import * as inflection from "inflection";
 import { pathToString } from "@bufbuild/protobuf/reflect";
@@ -802,18 +803,27 @@ function validateUUID(value, source) {
 * @returns Resolved workspace ID
 */
 async function loadWorkspaceId(opts) {
+	const workspaceId = await tryLoadWorkspaceId(opts);
+	if (workspaceId) return workspaceId;
+	throw new Error(multiline`
+    Workspace ID not found.
+    Please specify workspace ID via --workspace-id option or TAILOR_PLATFORM_WORKSPACE_ID environment variable.
+  `);
+}
+/**
+* Load a workspace ID when one is explicitly configured.
+* @param opts - Workspace and profile options
+* @returns Resolved workspace ID, or undefined when no source is configured
+*/
+async function tryLoadWorkspaceId(opts) {
 	const profile = opts?.profile || process.env.TAILOR_PLATFORM_PROFILE;
-	if (opts?.workspaceId) return validateUUID(opts.workspaceId, "--workspace-id option");
+	if (opts?.workspaceId !== void 0) return validateUUID(opts.workspaceId, "--workspace-id option");
 	if (process.env.TAILOR_PLATFORM_WORKSPACE_ID) return validateUUID(process.env.TAILOR_PLATFORM_WORKSPACE_ID, "TAILOR_PLATFORM_WORKSPACE_ID environment variable");
 	if (profile) {
 		const wsId = (await readPlatformConfig()).profiles[profile]?.workspace_id;
 		if (!wsId) throw new Error(`Profile "${profile}" not found`);
 		return validateUUID(wsId, `profile "${profile}"`);
 	}
-	throw new Error(multiline`
-    Workspace ID not found.
-    Please specify workspace ID via --workspace-id option or TAILOR_PLATFORM_WORKSPACE_ID environment variable.
-  `);
 }
 /**
 * Load machine user name from command options, environment variables, or platform config.
@@ -1228,14 +1238,18 @@ async function apiCall(options) {
 
 //#endregion
 //#region src/cli/shared/prompt.ts
+function canPrompt() {
+	return !isCI && process.stdin.isTTY === true && process.stdout.isTTY === true && !logger.jsonMode;
+}
 /**
 * Wraps a prompt function with CI guard and cancellation handling.
 * @param fn - A prompt function from `@inquirer/prompts`
+* @param unavailableMessage - Message used when interactive input is unavailable
 * @returns A wrapped function that throws in CI and exits on cancel
 */
-function withGuard(fn) {
+function withGuard(fn, unavailableMessage) {
 	return async (...args) => {
-		if (isCI) throw new CIPromptError();
+		if (!canPrompt()) throw new CIPromptError(unavailableMessage);
 		try {
 			return await fn(...args);
 		} catch (error) {
@@ -1245,9 +1259,10 @@ function withGuard(fn) {
 	};
 }
 const prompt = {
-	confirm: withGuard(confirm),
+	confirm: withGuard(confirm, "Interactive confirmations are not available in this environment. Use --yes to skip confirmation prompts, or provide the required options explicitly."),
 	text: withGuard(input),
-	password: withGuard(password)
+	password: withGuard(password),
+	select: withGuard(select)
 };
 
 //#endregion
@@ -11935,132 +11950,957 @@ async function validatePlan(input) {
 }
 
 //#endregion
-//#region src/cli/commands/deploy/deploy.ts
+//#region src/cli/shared/profile-name.ts
+const profileNameSchema = z.string().min(1, "Profile must not be empty");
+
+//#endregion
+//#region src/cli/shared/workspace-name.ts
+const workspaceNameSchema = z.string().min(3, "Name must be at least 3 characters").max(63, "Name must be at most 63 characters").regex(/^[a-z0-9-]+$/, "Name can only contain lowercase letters, numbers, and hyphens").refine((name) => !name.startsWith("-") && !name.endsWith("-"), "Name cannot start or end with a hyphen");
 /**
-* Resolve the set of IdP names that have at least one executor subscribed to
-* their user events. When an executor's idpUser trigger omits the `idp` option
-* and exactly one IdP is configured, that IdP is implicitly the target.
-* Executors that omit `idp` while multiple IdPs exist are skipped here; the
-* apply pipeline throws a clearer error for them later.
-* @param application - Loaded application
-* @returns Set of IdP names targeted by idpUser triggers
+* Validate a workspace name for use in an interactive prompt.
+* @param name - Candidate workspace name
+* @returns True when valid, otherwise a validation message
 */
-function collectIdpUserTriggerTargets(application) {
-	const targets = /* @__PURE__ */ new Set();
-	const idps = collectApplicationIdpNames(application);
-	for (const executor of Object.values(application.executorService?.executors ?? {})) {
-		if (executor.trigger.kind !== "idpUser") continue;
-		if (executor.trigger.idp != null) targets.add(executor.trigger.idp);
-		else if (idps.size === 1) {
-			const [idp] = idps;
-			if (idp) targets.add(idp);
-		}
-	}
-	return targets;
+function validateWorkspaceName(name) {
+	const result = workspaceNameSchema.safeParse(name);
+	return result.success ? true : assertDefined(result.error.issues[0], "Zod returned no issues").message;
 }
-function collectDeployIdpUserTriggerTargets(targets) {
-	const triggerTargets = /* @__PURE__ */ new Set();
-	for (const target of targets) for (const idpName of collectIdpUserTriggerTargets(target.application)) triggerTargets.add(idpName);
-	return triggerTargets;
+
+//#endregion
+//#region src/cli/shared/format.ts
+/**
+* Format a protobuf Timestamp to ISO string.
+* @param timestamp - Protobuf timestamp
+* @returns Date object or null if invalid
+*/
+function formatTimestamp(timestamp) {
+	if (!timestamp) return null;
+	const date = timestampDate(timestamp);
+	if (Number.isNaN(date.getTime())) return null;
+	return date;
 }
-function collectExecutorUsedTailorDBTypes(owner, targets) {
-	const usedTypes = /* @__PURE__ */ new Set();
-	const ownerNamespaces = new Set(owner.application.tailorDBServices.map((service) => service.namespace));
-	const applications = targets.map((target) => target.application);
-	for (const target of targets) {
-		const visibleNamespaces = collectVisibleTailorDBTypeNamespaces(target.application, applications);
-		for (const executor of Object.values(target.application.executorService?.executors ?? {})) if (executor.trigger.kind === "tailordb") {
-			const namespace = findTailorDBNamespace(target.application, executor.trigger.typeName) ?? resolveSameRunNamespace(visibleNamespaces, executor.trigger.typeName, "TailorDB type");
-			if (namespace && ownerNamespaces.has(namespace)) usedTypes.add(executor.trigger.typeName);
-		}
-	}
-	return usedTypes;
+/**
+* Formats a table with consistent single-line border style.
+* Use this instead of importing `table` directly.
+* @param data - Table data
+* @param config - Table configuration
+* @returns Formatted table string
+*/
+function formatTable(data, config) {
+	return table(data, {
+		...config,
+		border: getBorderCharacters("norc")
+	});
 }
-function collectExecutorUsedResolvers(owner, targets) {
-	const usedResolvers = /* @__PURE__ */ new Set();
-	const ownerNamespaces = new Set(owner.application.resolverServices.map((service) => service.namespace));
-	const applications = targets.map((target) => target.application);
-	for (const target of targets) {
-		const visibleNamespaces = collectVisibleResolverNamespaces(target.application, applications);
-		for (const executor of Object.values(target.application.executorService?.executors ?? {})) if (executor.trigger.kind === "resolverExecuted") {
-			const namespace = findResolverNamespace(target.application, executor.trigger.resolverName) ?? resolveSameRunNamespace(visibleNamespaces, executor.trigger.resolverName, "Resolver");
-			if (namespace && ownerNamespaces.has(namespace)) usedResolvers.add(executor.trigger.resolverName);
-		}
-	}
-	return usedResolvers;
+/**
+* Formats a key-value table with single-line border style.
+* @param data - Key-value pairs
+* @returns Formatted key-value table string
+*/
+function formatKeyValueTable(data) {
+	return formatTable(data, { singleLine: true });
 }
-function collectExpectedLocalStaticWebsiteNames(targets) {
-	const websiteNames = /* @__PURE__ */ new Set();
-	for (const target of targets) for (const website of target.application.staticWebsiteServices) websiteNames.add(website.name);
-	return websiteNames;
+/**
+* Format a Date or ISO timestamp string as a human-readable relative time.
+* @param value - Date object, ISO date string, or null
+* @returns Relative time (e.g., "5 minutes ago") or "N/A" for null/invalid
+*/
+function humanizeRelativeTime(value) {
+	if (value === null) return "N/A";
+	const date = value instanceof Date ? value : new Date(value);
+	if (Number.isNaN(date.getTime())) return typeof value === "string" ? value : "N/A";
+	return formatDistanceToNowStrict(date, { addSuffix: true });
 }
-function addPossiblyAmbiguousNamespace(namespaces, key, namespace) {
-	if (namespaces.has(key)) {
-		if (namespaces.get(key) !== namespace) namespaces.set(key, void 0);
+
+//#endregion
+//#region src/cli/commands/workspace/transform.ts
+const workspaceInfo = (workspace, folderName) => {
+	const info = {
+		id: workspace.id,
+		name: workspace.name,
+		region: workspace.region,
+		...workspace.organizationId ? { organizationId: workspace.organizationId } : {},
+		...workspace.folderId ? { folderId: workspace.folderId } : {},
+		createdAt: formatTimestamp(workspace.createTime),
+		updatedAt: formatTimestamp(workspace.updateTime)
+	};
+	return folderName ? {
+		...info,
+		folderName
+	} : info;
+};
+const workspaceDetails = (workspace, folderName) => {
+	return {
+		...workspaceInfo(workspace, folderName),
+		deleteProtection: workspace.deleteProtection,
+		organizationId: workspace.organizationId,
+		folderId: workspace.folderId
+	};
+};
+async function resolveWorkspaceFolderName(client, workspace) {
+	if (!workspace.organizationId || !workspace.folderId) return void 0;
+	try {
+		return (await client.getOrganizationFolder({
+			organizationId: workspace.organizationId,
+			folderId: workspace.folderId
+		})).folder?.name || void 0;
+	} catch (error) {
+		if (error instanceof ConnectError && (error.code === Code.NotFound || error.code === Code.PermissionDenied)) return;
+		logger.warn(`Failed to resolve workspace folder name: ${error}`);
 		return;
 	}
-	namespaces.set(key, namespace);
 }
-function collectVisibleResources(params) {
-	const { application, applications, visibleKeysOf, resourcesOf, createResult, addResource } = params;
-	const visibleKeys = visibleKeysOf(application);
-	const result = createResult();
-	for (const candidate of applications) for (const resource of resourcesOf(candidate)) {
-		if (!visibleKeys.has(resource.visibilityKey)) continue;
-		addResource(result, resource.resourceKey, resource.visibilityKey);
-	}
-	return result;
+function createWorkspaceFolderNameResolver(client) {
+	const cache = /* @__PURE__ */ new Map();
+	return (workspace) => {
+		if (!workspace.organizationId || !workspace.folderId) return Promise.resolve(void 0);
+		const cacheKey = `${workspace.organizationId}/${workspace.folderId}`;
+		const cached = cache.get(cacheKey);
+		if (cached) return cached;
+		const promise = resolveWorkspaceFolderName(client, workspace);
+		cache.set(cacheKey, promise);
+		return promise;
+	};
 }
-function collectApplicationTailorDBNamespaces(application) {
-	return /* @__PURE__ */ new Set([...application.tailorDBServices.map((service) => service.namespace), ...application.externalTailorDBNamespaces]);
+async function workspaceInfoWithFolderName(client, workspace) {
+	const folderName = await resolveWorkspaceFolderName(client, workspace);
+	return workspaceInfo(workspace, folderName);
 }
-function* tailorDBTypeResources(application) {
-	for (const service of application.tailorDBServices) for (const typeName of Object.keys(service.types)) yield {
-		visibilityKey: service.namespace,
-		resourceKey: typeName
-	};
+async function workspaceDetailsWithFolderName(client, workspace) {
+	const folderName = await resolveWorkspaceFolderName(client, workspace);
+	return workspaceDetails(workspace, folderName);
 }
-function collectVisibleTailorDBTypeNamespaces(application, applications) {
-	return collectVisibleResources({
-		application,
-		applications,
-		visibleKeysOf: collectApplicationTailorDBNamespaces,
-		resourcesOf: tailorDBTypeResources,
-		createResult: () => /* @__PURE__ */ new Map(),
-		addResource: addPossiblyAmbiguousNamespace
-	});
+async function workspaceInfosWithFolderNames(client, workspaces) {
+	const resolveFolderName = createWorkspaceFolderNameResolver(client);
+	const limit = pLimit(5);
+	return Promise.all(workspaces.map((workspace) => limit(async () => workspaceInfo(workspace, await resolveFolderName(workspace)))));
 }
-function collectApplicationResolverNamespaces(application) {
-	return new Set(application.subgraphs.filter((subgraph) => subgraph.Type === "pipeline").map((subgraph) => subgraph.Name));
+function workspaceDisplayName(workspace) {
+	return workspace.folderName ? `${workspace.folderName}/${workspace.name}` : workspace.name;
 }
-function* idpNameResources(application) {
-	for (const name of collectApplicationIdpNames(application)) yield {
-		visibilityKey: name,
-		resourceKey: name
+function createWorkspaceNameTransformer(nameKey, folderNameKey) {
+	return (value, item) => {
+		const workspace = item;
+		const name = workspace[nameKey];
+		const folderName = workspace[folderNameKey];
+		if (typeof name === "string" && typeof folderName === "string") return workspaceDisplayName({
+			name,
+			folderName
+		});
+		return String(value ?? "");
 	};
 }
-function collectVisibleIdpNames(application, applications) {
-	return collectVisibleResources({
-		application,
-		applications,
-		visibleKeysOf: collectApplicationIdpNames,
-		resourcesOf: idpNameResources,
-		createResult: () => /* @__PURE__ */ new Set(),
-		addResource: (names, name) => {
-			names.add(name);
-		}
-	});
-}
-function* resolverResources(application) {
-	for (const service of application.resolverServices) for (const resolver of Object.values(service.resolvers)) yield {
-		visibilityKey: service.namespace,
-		resourceKey: resolver.name
+const workspaceNameTransformer = createWorkspaceNameTransformer("name", "folderName");
+
+//#endregion
+//#region src/cli/commands/workspace/create.ts
+/**
+* Schema for workspace creation options
+* - name: 3-63 chars, lowercase alphanumeric and hyphens, cannot start/end with hyphen
+* - organizationId, folderId: optional UUIDs
+*/
+const createWorkspaceOptionsSchema = z.object({
+	name: workspaceNameSchema,
+	region: z.string(),
+	deleteProtection: z.boolean().optional(),
+	organizationId: z.uuid().optional(),
+	folderId: z.uuid().optional(),
+	profile: profileNameSchema.optional()
+});
+const validateRegion = async (region, client) => {
+	const availableRegions = await client.listAvailableWorkspaceRegions({});
+	if (!availableRegions.regions.includes(region)) throw new Error(`Region must be one of: ${availableRegions.regions.join(", ")}.`);
+};
+function profilePlatformSettings(platformConfig) {
+	const hasOAuth2ClientId = platformConfig?.oauth2ClientId || process.env.TAILOR_PLATFORM_OAUTH2_CLIENT_ID;
+	const hasConsoleUrl = platformConfig?.consoleUrl || process.env.TAILOR_PLATFORM_CONSOLE_URL;
+	return {
+		...isDefaultPlatform(platformConfig) ? {} : { platform_url: getPlatformBaseUrl(platformConfig) },
+		...hasOAuth2ClientId ? { oauth2_client_id: getOAuth2ClientId(platformConfig) } : {},
+		...hasConsoleUrl ? { console_url: getConsoleBaseUrl(platformConfig) } : {}
 	};
 }
-function collectVisibleResolverNamespaces(application, applications) {
-	return collectVisibleResources({
-		application,
-		applications,
+/**
+* Create a new workspace with the given options.
+* @param options - Workspace creation options
+* @returns Created workspace info
+*/
+async function createWorkspace$1(options) {
+	const validated = validateCreateWorkspaceOptions(options);
+	const client = await initOperatorClient(await loadAccessToken({ profile: validated.profile }), await loadPlatformClientConfig({ profile: validated.profile }));
+	await validateRegion(validated.region, client);
+	return createValidatedWorkspaceWithClient(client, validated);
+}
+/**
+* Create a workspace after its local options and region have been validated.
+* @param client - Authenticated Operator client
+* @param options - Validated workspace creation options
+* @returns Created workspace info
+*/
+async function createValidatedWorkspaceWithClient(client, options) {
+	return workspaceInfoWithFolderName(client, assertDefined((await client.createWorkspace({
+		workspaceName: options.name,
+		workspaceRegion: options.region,
+		deleteProtection: options.deleteProtection ?? false,
+		organizationId: options.organizationId,
+		folderId: options.folderId
+	})).workspace, "createWorkspace response missing workspace"));
+}
+/**
+* Validate workspace creation options without making API calls.
+* @param options - Workspace creation options
+* @returns Validated workspace creation options
+*/
+function validateCreateWorkspaceOptions(options) {
+	const result = createWorkspaceOptionsSchema.safeParse(options);
+	if (!result.success) throw new Error(assertDefined(result.error.issues[0], "Zod returned no issues").message);
+	return result.data;
+}
+const createCommand$1 = defineAppCommand({
+	name: "create",
+	description: "Create a new Tailor Platform workspace.",
+	args: z.object({
+		name: arg(z.string(), {
+			alias: "n",
+			description: "Workspace name"
+		}),
+		region: arg(z.string(), {
+			alias: "r",
+			description: "Workspace region (us-west, asia-northeast)"
+		}),
+		"delete-protection": arg(z.boolean().default(false), {
+			alias: "d",
+			description: "Enable delete protection"
+		}),
+		"organization-id": arg(z.string().optional(), {
+			alias: "o",
+			description: "Organization ID to workspace associate with",
+			env: "TAILOR_PLATFORM_ORGANIZATION_ID"
+		}),
+		"folder-id": arg(z.string().optional(), {
+			alias: "f",
+			description: "Folder ID to workspace associate with",
+			env: "TAILOR_PLATFORM_FOLDER_ID"
+		}),
+		"profile-name": arg(z.string().optional(), {
+			alias: "p",
+			description: "Profile name to create"
+		}),
+		profile: arg(profileNameSchema.optional(), {
+			description: "Workspace profile used for authentication and Platform selection",
+			env: "TAILOR_PLATFORM_PROFILE"
+		}),
+		"profile-user": arg(z.string().optional(), { description: "User email for the profile (defaults to current user)" }),
+		permission: arg(z.enum(["write", "read"]).default("write"), { description: "Profile permission (requires --profile-name). 'read' blocks all write commands while the profile is active." })
+	}).strict(),
+	run: async (args) => {
+		await assertWritable({ profile: args.profile });
+		const profileName = args["profile-name"];
+		let profileSetup;
+		if (profileName) {
+			const config = await readPlatformConfig();
+			if (config.profiles[profileName]) throw new Error(`Profile "${profileName}" already exists.`);
+			const activeProfileName = args.profile;
+			const activeProfileEntry = activeProfileName ? config.profiles[activeProfileName] : void 0;
+			const platformConfig = activeProfileEntry ? platformConfigFromProfile(activeProfileEntry) : void 0;
+			const profileUser = args["profile-user"] || activeProfileEntry?.user || config.current_user;
+			if (!profileUser) throw new Error("Current user not found. Please login or specify --profile-user to create a profile.");
+			if (!hasUserTokenEntry(config, profileUser, platformConfig)) throw new Error(`User "${profileUser}" not found.\nPlease verify your user name and login using 'tailor-sdk login' command.`);
+			profileSetup = {
+				name: profileName,
+				user: profileUser,
+				platformSettings: profilePlatformSettings(platformConfig)
+			};
+		}
+		const workspace = await createWorkspace$1({
+			name: args.name,
+			region: args.region,
+			deleteProtection: args["delete-protection"],
+			organizationId: args["organization-id"],
+			folderId: args["folder-id"],
+			profile: args.profile
+		});
+		let profileInfo;
+		if (profileSetup) {
+			const config = await readPlatformConfig();
+			const platformSettings = profileSetup.platformSettings;
+			config.profiles[profileSetup.name] = {
+				user: profileSetup.user,
+				workspace_id: workspace.id,
+				...args.permission === "read" ? { readonly: true } : {},
+				...platformSettings
+			};
+			writePlatformConfig(config);
+			profileInfo = {
+				name: profileSetup.name,
+				user: profileSetup.user,
+				workspaceId: workspace.id,
+				permission: args.permission,
+				...platformSettings.platform_url ? { platformUrl: platformSettings.platform_url } : {},
+				...platformSettings.oauth2_client_id ? { oauth2ClientId: platformSettings.oauth2_client_id } : {},
+				...platformSettings.console_url ? { consoleUrl: platformSettings.console_url } : {}
+			};
+			if (!args.json) logger.success(`Profile "${profileSetup.name}" created successfully.`);
+		}
+		if (!args.json) logger.success(`Workspace "${workspaceDisplayName(workspace)}" created successfully.`);
+		if (args.json && profileInfo) {
+			logger.out({
+				...workspace,
+				profile: profileInfo
+			});
+			return;
+		}
+		logger.out(workspace, { display: {
+			name: workspaceNameTransformer,
+			folderName: null
+		} });
+		if (profileInfo) {
+			logger.out("Profile:");
+			logger.out(profileInfo);
+		}
+	}
+});
+
+//#endregion
+//#region src/cli/commands/workspace/list.ts
+/**
+* List workspaces with an optional order and limit.
+* @param options - Workspace listing options
+* @returns List of workspaces
+*/
+async function listWorkspaces(options) {
+	const profile = profileNameSchema.optional().parse(options?.profile);
+	return listWorkspacesWithClient(await initOperatorClient(await loadAccessToken({ profile }), await loadPlatformClientConfig({ profile })), options);
+}
+/**
+* List workspaces using an existing Operator client.
+* @param client - Authenticated Operator client
+* @param options - Workspace listing options
+* @returns List of workspaces
+*/
+async function listWorkspacesWithClient(client, options) {
+	const pageDirection = toPageDirection(options?.order);
+	return workspaceInfosWithFolderNames(client, await fetchPaged(async (pageToken, pageSize) => {
+		const { workspaces, nextPageToken } = await client.listWorkspaces({
+			pageToken,
+			pageSize,
+			pageDirection
+		});
+		return [workspaces, nextPageToken];
+	}, { limit: options?.limit }));
+}
+const listCommand$9 = defineAppCommand({
+	name: "list",
+	description: "List all Tailor Platform workspaces.",
+	args: z.object({
+		...paginationArgs(),
+		profile: arg(profileNameSchema.optional(), {
+			description: "Workspace profile used for authentication and Platform selection",
+			env: "TAILOR_PLATFORM_PROFILE"
+		})
+	}).strict(),
+	run: async (args) => {
+		const workspaces = await listWorkspaces({
+			order: args.order,
+			limit: args.limit,
+			profile: args.profile
+		});
+		logger.out(workspaces, { display: {
+			name: workspaceNameTransformer,
+			folderName: null,
+			organizationId: null,
+			folderId: null,
+			updatedAt: null
+		} });
+	}
+});
+
+//#endregion
+//#region src/cli/commands/deploy/workspace-context.ts
+const workspaceContextSchema = z.object({
+	version: z.literal(1),
+	platformUrl: z.url(),
+	applicationId: z.string().min(1).optional(),
+	workspaceId: z.uuid()
+});
+function defaultConfigPath() {
+	return resolve(process.cwd(), "tailor.config.ts");
+}
+function contextPath(configPath) {
+	return join(dirname(configPath), ".tailor-sdk", `${basename(configPath)}.context.json`);
+}
+/**
+* Load the project workspace context when it belongs to the current platform.
+* Missing, malformed, and cross-platform state is ignored.
+* @param platformUrl - Current Platform API base URL
+* @param configPath - Configuration file whose workspace selection is loaded
+* @param applicationId - Application identity that must match the saved context
+* @returns Valid context for the current platform, or undefined
+*/
+async function loadWorkspaceContext(platformUrl, configPath = defaultConfigPath(), applicationId) {
+	let contents;
+	try {
+		contents = await readFile(contextPath(configPath), "utf8");
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return void 0;
+		throw error;
+	}
+	let value;
+	try {
+		value = JSON.parse(contents);
+	} catch {
+		return;
+	}
+	const result = workspaceContextSchema.safeParse(value);
+	if (!result.success || result.data.platformUrl !== platformUrl || applicationId !== void 0 && result.data.applicationId !== applicationId) return;
+	return result.data;
+}
+/**
+* Persist the selected workspace as project-local SDK state.
+* @param context - Workspace context to persist
+* @param configPath - Configuration file whose workspace selection is persisted
+* @param applicationId - Application identity stored with the workspace selection
+*/
+async function saveWorkspaceContext(context, configPath = defaultConfigPath(), applicationId) {
+	const validated = workspaceContextSchema.parse({
+		...context,
+		...applicationId === void 0 ? {} : { applicationId }
+	});
+	const stateDirectory = join(dirname(configPath), ".tailor-sdk");
+	const targetPath = contextPath(configPath);
+	const serialized = `${JSON.stringify(validated, null, 2)}\n`;
+	try {
+		if (await readFile(targetPath, "utf8") === serialized) return;
+	} catch {}
+	const temporaryPath = `${targetPath}.${process.pid}.${randomUUID()}.tmp`;
+	await mkdir(stateDirectory, { recursive: true });
+	try {
+		await writeFile(temporaryPath, serialized, { mode: 384 });
+		await rename(temporaryPath, targetPath);
+	} catch (error) {
+		await rm(temporaryPath, { force: true }).catch(() => void 0);
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/cli/commands/deploy/workspace.ts
+function suggestedWorkspaceName() {
+	const name = basename(process.cwd()).toLowerCase().replaceAll(/[^a-z0-9-]+/g, "-").replaceAll(/^-+|-+$/g, "").slice(0, 63).replace(/-+$/, "");
+	return validateWorkspaceName(name) === true ? name : "my-workspace";
+}
+function executableAction(args) {
+	return {
+		command: "tailor-sdk",
+		args
+	};
+}
+function deployArgs(options) {
+	return options.deployArgs ?? ["deploy"];
+}
+function workspaceCommandArgs(options) {
+	return options.workspaceCommandArgs ?? [];
+}
+function createDeployArgs(options, name, region) {
+	return [
+		...deployArgs(options),
+		"--create-workspace",
+		"--workspace-name",
+		name,
+		"--workspace-region",
+		region,
+		...options.organizationId ? ["--organization-id", options.organizationId] : [],
+		...options.folderId ? ["--folder-id", options.folderId] : []
+	];
+}
+function selectDeployArgs(options) {
+	return [
+		...deployArgs(options),
+		"--workspace-id",
+		"<workspace-id>"
+	];
+}
+function workspaceLabel(workspace) {
+	const organization = workspace.organizationId ?? "personal";
+	return `${workspaceDisplayName(workspace)} (${workspace.region}, org: ${organization}, id: ${workspace.id})`;
+}
+function workspaceMatchesRequestedIdentity(workspace, options) {
+	return options.workspaceName === workspace.name && options.workspaceRegion === workspace.region && options.organizationId === workspace.organizationId && options.folderId === workspace.folderId;
+}
+function workspaceIdentity(workspace) {
+	const { id, name, region, organizationId, folderId } = workspace;
+	return {
+		id,
+		name,
+		region,
+		organizationId,
+		folderId
+	};
+}
+function projectContextTargets(contextTargets) {
+	if (!contextTargets) return void 0;
+	return [...new Map(contextTargets.map((target) => [target.configPath, target])).values()];
+}
+async function loadProjectContexts(platformUrl, contextTargets) {
+	const targets = projectContextTargets(contextTargets);
+	if (!targets || targets.length === 0) {
+		const context = await loadWorkspaceContext(platformUrl);
+		return context ? [context] : [];
+	}
+	return (await Promise.all(targets.map(({ configPath, applicationId }) => loadWorkspaceContext(platformUrl, configPath, applicationId)))).filter((context) => context !== void 0);
+}
+async function persistWorkspaceContext(context, contextTargets) {
+	const targets = projectContextTargets(contextTargets);
+	if (!targets || targets.length === 0) {
+		await saveWorkspaceContext(context);
+		return;
+	}
+	const failures = (await Promise.allSettled(targets.map(({ configPath, applicationId }) => saveWorkspaceContext(context, configPath, applicationId)))).filter((result) => result.status === "rejected");
+	if (failures.length > 0) throw new Error(failures.map(({ reason }) => reason instanceof Error ? reason.message : String(reason)).join("; "));
+}
+async function rememberWorkspaceContext(context, options, failurePolicy = "error-on-partial") {
+	if (options.dryRun) return;
+	try {
+		await persistWorkspaceContext(context, options.contextTargets);
+	} catch (error) {
+		if ((projectContextTargets(options.contextTargets)?.length ?? 0) > 1 && failurePolicy === "error-on-partial") throw createCLIError({
+			code: "WORKSPACE_CONTEXT_SAVE_FAILED",
+			message: "The workspace selection could not be saved for every configuration file.",
+			details: error instanceof Error ? error.message : String(error),
+			suggestion: "Fix project state permissions, then rerun deploy with the workspace ID.",
+			next: executableAction([
+				...deployArgs(options),
+				"--workspace-id",
+				context.workspaceId
+			]),
+			context: {
+				workspaceId: context.workspaceId,
+				configPaths: options.contextTargets?.map(({ configPath }) => configPath)
+			}
+		});
+		logger.warn(`Could not save the project workspace selection (${error instanceof Error ? error.message : String(error)}). Continue with --workspace-id ${context.workspaceId} on later runs.`);
+	}
+}
+async function useWorkspace(client, platformUrl, workspace, options, failurePolicy = "error-on-partial") {
+	await rememberWorkspaceContext({
+		version: 1,
+		platformUrl,
+		workspaceId: workspace.id
+	}, options, failurePolicy);
+	logger.info(`Using workspace: ${workspaceLabel(workspace)}`);
+	return {
+		client,
+		workspaceId: workspace.id
+	};
+}
+function useRememberedWorkspace(client, workspace) {
+	logger.warn(`Using saved workspace selection: ${workspaceLabel(workspace)}`);
+	return {
+		client,
+		workspaceId: workspace.id
+	};
+}
+const createNewWorkspaceSelection = "create-new-workspace";
+async function chooseWorkspace(client, platformUrl, workspaces, options) {
+	const workspaceId = await prompt.select({
+		message: "Select a workspace",
+		choices: [...workspaces.map((workspace) => ({
+			name: workspaceLabel(workspace),
+			value: workspace.id
+		})), {
+			name: "Create new workspace",
+			value: createNewWorkspaceSelection
+		}]
+	});
+	if (workspaceId === createNewWorkspaceSelection) return createWorkspaceForDeploy(client, platformUrl, options);
+	const workspace = workspaces.find(({ id }) => id === workspaceId);
+	if (!workspace) throw new Error("Selected workspace was not found");
+	return useWorkspace(client, platformUrl, workspace, options);
+}
+function invalidCreateOptionsError(options, name, region, details) {
+	return createCLIError({
+		code: "WORKSPACE_CREATE_OPTIONS_INVALID",
+		message: "Workspace creation options are invalid.",
+		details,
+		suggestion: "Correct the workspace creation options and rerun deploy.",
+		next: executableAction(createDeployArgs(options, name, region))
+	});
+}
+async function createWorkspace(client, platformUrl, options, availableRegions, validatedOptions) {
+	let name = options.workspaceName;
+	let region = options.workspaceRegion;
+	const interactive = canPrompt();
+	if (interactive) {
+		name ??= await prompt.text({
+			message: "Workspace name",
+			default: suggestedWorkspaceName(),
+			validate: validateWorkspaceName
+		});
+		region ??= await prompt.select({
+			message: "Workspace region",
+			choices: availableRegions.map((value) => ({
+				name: value,
+				value
+			}))
+		});
+	} else {
+		const missingOptions = [...name === void 0 ? ["--workspace-name"] : [], ...region === void 0 ? ["--workspace-region"] : []];
+		if (missingOptions.length > 0) throw createCLIError({
+			code: "WORKSPACE_CREATE_OPTIONS_REQUIRED",
+			message: "Workspace creation requires a name and region in non-interactive mode.",
+			suggestion: "Provide every workspace creation option and rerun deploy.",
+			next: executableAction(createDeployArgs(options, name ?? "<name>", region ?? "<region>")),
+			context: { missingOptions }
+		});
+	}
+	if (!name || !region) throw new Error("Workspace creation options were not resolved");
+	let validated = validatedOptions;
+	if (!validated) {
+		try {
+			validated = validateCreateWorkspaceOptions({
+				name,
+				region,
+				organizationId: options.organizationId,
+				folderId: options.folderId
+			});
+		} catch (error) {
+			throw invalidCreateOptionsError(options, name, region, error instanceof Error ? error.message : String(error));
+		}
+		if (!availableRegions.includes(region)) throw invalidCreateOptionsError(options, name, region, `Region must be one of: ${availableRegions.join(", ")}.`);
+	}
+	if (interactive) {
+		const scope = [options.organizationId ? `organization: ${options.organizationId}` : void 0, options.folderId ? `folder: ${options.folderId}` : void 0].filter((value) => value !== void 0);
+		if (!await prompt.confirm({
+			message: `Create workspace "${name}" in ${region}${scope.length > 0 ? ` (${scope.join(", ")})` : ""}?`,
+			default: true
+		})) throw createCLIError({
+			code: "WORKSPACE_CREATION_CANCELLED",
+			message: "Workspace creation was cancelled."
+		});
+	}
+	let workspace;
+	try {
+		workspace = await createValidatedWorkspaceWithClient(client, validated);
+	} catch (error) {
+		if (error instanceof ConnectError && ![
+			Code.Canceled,
+			Code.Unknown,
+			Code.DeadlineExceeded,
+			Code.Aborted,
+			Code.Internal,
+			Code.Unavailable,
+			Code.DataLoss
+		].includes(error.code)) throw error;
+		throw createCLIError({
+			code: "WORKSPACE_CREATION_FAILED",
+			message: "Workspace creation did not complete successfully.",
+			details: error instanceof Error ? error.message : String(error),
+			suggestion: "The outcome may be uncertain. List workspaces before retrying creation to avoid duplicates.",
+			next: executableAction([
+				"workspace",
+				"list",
+				...workspaceCommandArgs(options),
+				"--json"
+			])
+		});
+	}
+	await rememberWorkspaceContext({
+		version: 1,
+		platformUrl,
+		workspaceId: workspace.id
+	}, options);
+	logger.success(`Created workspace: ${workspaceLabel(workspace)}`);
+	logger.info(`Reuse this workspace with: tailor-sdk deploy --workspace-id ${workspace.id}`);
+	logger.info(`Or set TAILOR_PLATFORM_WORKSPACE_ID=${workspace.id}.`);
+	return {
+		client,
+		workspaceId: workspace.id
+	};
+}
+async function createWorkspaceForDeploy(client, platformUrl, options, requestedRegions, validatedOptions) {
+	const regions = requestedRegions ?? (await client.listAvailableWorkspaceRegions({})).regions;
+	if (options.dryRun) throw createCLIError({
+		code: "WORKSPACE_CREATION_DISABLED_IN_DRY_RUN",
+		message: "Dry-run cannot create the workspace required to build a deployment plan.",
+		suggestion: "Create a workspace explicitly, then rerun the same dry-run with its workspace ID.",
+		context: { availableRegions: regions }
+	});
+	return createWorkspace(client, platformUrl, options, regions, validatedOptions);
+}
+/**
+* Resolve or provision the workspace used by deploy.
+* Explicit configuration wins over project context and account discovery.
+* @param options - Deploy workspace selection and creation options
+* @returns Authenticated client and resolved workspace ID
+*/
+async function resolveDeployWorkspace(options = {}) {
+	const createOptionNames = [options.workspaceName !== void 0 ? "--workspace-name" : void 0, options.workspaceRegion !== void 0 ? "--workspace-region" : void 0].filter((name) => name !== void 0);
+	if (!options.createWorkspace && createOptionNames.length > 0) throw createCLIError({
+		code: "WORKSPACE_CREATE_FLAG_REQUIRED",
+		message: "Workspace creation options require --create-workspace.",
+		suggestion: "Add --create-workspace or remove the workspace creation options.",
+		next: executableAction(createDeployArgs(options, options.workspaceName ?? "<name>", options.workspaceRegion ?? "<region>")),
+		context: { options: createOptionNames }
+	});
+	if (options.createWorkspace && options.workspaceName !== void 0) {
+		const nameValidation = validateWorkspaceName(options.workspaceName);
+		if (nameValidation !== true) throw invalidCreateOptionsError(options, options.workspaceName, options.workspaceRegion ?? "<region>", nameValidation);
+	}
+	if (options.createWorkspace && options.workspaceRegion === "") throw invalidCreateOptionsError(options, options.workspaceName ?? "<name>", options.workspaceRegion, "Region must not be empty.");
+	const explicitWorkspaceId = await tryLoadWorkspaceId({
+		workspaceId: options.workspaceId,
+		profile: options.profile
+	});
+	const accessToken = await loadAccessToken({ profile: options.profile });
+	const platformConfig = await loadPlatformClientConfig({
+		profile: options.profile,
+		allowMissingProfile: explicitWorkspaceId !== void 0
+	});
+	const platformUrl = getPlatformBaseUrl(platformConfig);
+	const client = await initOperatorClient(accessToken, platformConfig);
+	if (explicitWorkspaceId) {
+		let response;
+		try {
+			response = await client.getWorkspace({ workspaceId: explicitWorkspaceId });
+		} catch (error) {
+			if (error instanceof ConnectError && error.code === Code.NotFound) throw createCLIError({
+				code: "WORKSPACE_NOT_FOUND",
+				message: `Workspace "${explicitWorkspaceId}" was not found.`
+			});
+			throw error;
+		}
+		if (!response.workspace) throw createCLIError({
+			code: "WORKSPACE_NOT_FOUND",
+			message: `Workspace "${explicitWorkspaceId}" was not found.`
+		});
+		return useWorkspace(client, platformUrl, workspaceInfo(response.workspace), options, "warn");
+	}
+	let requestedCreateOptions;
+	if (options.createWorkspace && options.workspaceName !== void 0 && options.workspaceRegion !== void 0) try {
+		requestedCreateOptions = validateCreateWorkspaceOptions({
+			name: options.workspaceName,
+			region: options.workspaceRegion,
+			organizationId: options.organizationId,
+			folderId: options.folderId
+		});
+	} catch (error) {
+		throw invalidCreateOptionsError(options, options.workspaceName, options.workspaceRegion, error instanceof Error ? error.message : String(error));
+	}
+	const [contexts, workspaces] = await Promise.all([loadProjectContexts(platformUrl, options.contextTargets), listWorkspacesWithClient(client)]);
+	const interactive = canPrompt();
+	const contextWorkspaceIds = new Set(contexts.map(({ workspaceId }) => workspaceId));
+	const linkedWorkspace = contextWorkspaceIds.size === 1 ? workspaces.find(({ id }) => contextWorkspaceIds.has(id)) : void 0;
+	if (linkedWorkspace && (!options.createWorkspace || workspaceMatchesRequestedIdentity(linkedWorkspace, options))) {
+		const contextTargetCount = projectContextTargets(options.contextTargets)?.length ?? 1;
+		return contexts.length === contextTargetCount ? useRememberedWorkspace(client, linkedWorkspace) : useWorkspace(client, platformUrl, linkedWorkspace, options);
+	}
+	const onlyWorkspace = workspaces.length === 1 ? workspaces[0] : void 0;
+	const canReuseOnlyWorkspace = onlyWorkspace !== void 0 && requestedCreateOptions !== void 0 && workspaceMatchesRequestedIdentity(onlyWorkspace, options);
+	let requestedRegions;
+	if (requestedCreateOptions && !canReuseOnlyWorkspace) {
+		requestedRegions = await client.listAvailableWorkspaceRegions({});
+		if (!requestedRegions.regions.includes(requestedCreateOptions.region)) throw invalidCreateOptionsError(options, requestedCreateOptions.name, requestedCreateOptions.region, `Region must be one of: ${requestedRegions.regions.join(", ")}.`);
+	}
+	if (workspaces.length === 0 && (interactive || options.createWorkspace || contexts.length === 0)) {
+		const regions = requestedRegions?.regions ?? (await client.listAvailableWorkspaceRegions({})).regions;
+		if (options.dryRun || interactive || options.createWorkspace) return createWorkspaceForDeploy(client, platformUrl, options, regions, requestedCreateOptions);
+		throw createCLIError({
+			code: "WORKSPACE_NOT_FOUND",
+			message: "No workspaces are available for this account.",
+			suggestion: "Create one during deploy by providing the workspace name and one of the available regions.",
+			next: executableAction(createDeployArgs(options, "<name>", "<region>")),
+			context: { availableRegions: regions }
+		});
+	}
+	if (contextWorkspaceIds.size > 1) {
+		const canReplaceStaleContexts = options.createWorkspace === true && options.workspaceName !== void 0 && options.workspaceRegion !== void 0 && workspaces.length === 0;
+		if (!interactive && !canReplaceStaleContexts) throw createCLIError({
+			code: "WORKSPACE_CONTEXT_CONFLICT",
+			message: "The deployed configuration files are linked to different workspaces.",
+			suggestion: "Choose one workspace explicitly for the combined deployment.",
+			next: executableAction(selectDeployArgs(options)),
+			context: { savedWorkspaceIds: [...contextWorkspaceIds] }
+		});
+		if (workspaces.length > 0 && !options.createWorkspace) return chooseWorkspace(client, platformUrl, workspaces, options);
+	}
+	if (!linkedWorkspace && contexts.length > 0) {
+		const explicitlyEnsuringSingleTarget = options.createWorkspace === true && options.workspaceName !== void 0 && options.workspaceRegion !== void 0 && workspaces.length <= 1;
+		if (!interactive && !explicitlyEnsuringSingleTarget) throw createCLIError({
+			code: "WORKSPACE_CONTEXT_STALE",
+			message: "The saved project workspace is no longer available.",
+			suggestion: "Choose an available workspace explicitly before deploying.",
+			next: executableAction(selectDeployArgs(options)),
+			context: {
+				savedWorkspaceIds: [...contextWorkspaceIds],
+				workspaces: workspaces.map(workspaceIdentity)
+			}
+		});
+		if (workspaces.length > 0 && interactive && !options.createWorkspace) return chooseWorkspace(client, platformUrl, workspaces, options);
+	}
+	if (workspaces.length === 1) {
+		const [workspace] = workspaces;
+		if (!workspace) throw new Error("Workspace discovery returned an invalid result");
+		if (options.createWorkspace && !workspaceMatchesRequestedIdentity(workspace, options)) throw createCLIError({
+			code: "WORKSPACE_CREATE_CONFLICT",
+			message: "The existing workspace does not match the requested workspace.",
+			suggestion: "Use the existing workspace, or run the explicit workspace create command to create another one.",
+			next: executableAction([
+				"workspace",
+				"create",
+				...workspaceCommandArgs(options),
+				...options.workspaceCommandJson ? ["--json"] : [],
+				"--name",
+				options.workspaceName ?? "<name>",
+				"--region",
+				options.workspaceRegion ?? "<region>",
+				...options.organizationId ? ["--organization-id", options.organizationId] : [],
+				...options.folderId ? ["--folder-id", options.folderId] : []
+			]),
+			context: { existingWorkspace: workspaceIdentity(workspace) }
+		});
+		if (interactive && !options.createWorkspace) return chooseWorkspace(client, platformUrl, workspaces, options);
+		return useWorkspace(client, platformUrl, workspace, options);
+	}
+	if (workspaces.length > 1) {
+		if (!interactive) throw createCLIError({
+			code: "WORKSPACE_SELECTION_REQUIRED",
+			message: "Multiple workspaces are available.",
+			suggestion: "Choose one explicitly for non-interactive deployment.",
+			next: executableAction(selectDeployArgs(options)),
+			context: { workspaces: workspaces.map(workspaceIdentity) }
+		});
+		return chooseWorkspace(client, platformUrl, workspaces, options);
+	}
+	throw new Error("Workspace discovery returned an invalid result");
+}
+
+//#endregion
+//#region src/cli/commands/deploy/deploy.ts
+/**
+* Resolve the set of IdP names that have at least one executor subscribed to
+* their user events. When an executor's idpUser trigger omits the `idp` option
+* and exactly one IdP is configured, that IdP is implicitly the target.
+* Executors that omit `idp` while multiple IdPs exist are skipped here; the
+* apply pipeline throws a clearer error for them later.
+* @param application - Loaded application
+* @returns Set of IdP names targeted by idpUser triggers
+*/
+function collectIdpUserTriggerTargets(application) {
+	const targets = /* @__PURE__ */ new Set();
+	const idps = collectApplicationIdpNames(application);
+	for (const executor of Object.values(application.executorService?.executors ?? {})) {
+		if (executor.trigger.kind !== "idpUser") continue;
+		if (executor.trigger.idp != null) targets.add(executor.trigger.idp);
+		else if (idps.size === 1) {
+			const [idp] = idps;
+			if (idp) targets.add(idp);
+		}
+	}
+	return targets;
+}
+function collectDeployIdpUserTriggerTargets(targets) {
+	const triggerTargets = /* @__PURE__ */ new Set();
+	for (const target of targets) for (const idpName of collectIdpUserTriggerTargets(target.application)) triggerTargets.add(idpName);
+	return triggerTargets;
+}
+function collectExecutorUsedTailorDBTypes(owner, targets) {
+	const usedTypes = /* @__PURE__ */ new Set();
+	const ownerNamespaces = new Set(owner.application.tailorDBServices.map((service) => service.namespace));
+	const applications = targets.map((target) => target.application);
+	for (const target of targets) {
+		const visibleNamespaces = collectVisibleTailorDBTypeNamespaces(target.application, applications);
+		for (const executor of Object.values(target.application.executorService?.executors ?? {})) if (executor.trigger.kind === "tailordb") {
+			const namespace = findTailorDBNamespace(target.application, executor.trigger.typeName) ?? resolveSameRunNamespace(visibleNamespaces, executor.trigger.typeName, "TailorDB type");
+			if (namespace && ownerNamespaces.has(namespace)) usedTypes.add(executor.trigger.typeName);
+		}
+	}
+	return usedTypes;
+}
+function collectExecutorUsedResolvers(owner, targets) {
+	const usedResolvers = /* @__PURE__ */ new Set();
+	const ownerNamespaces = new Set(owner.application.resolverServices.map((service) => service.namespace));
+	const applications = targets.map((target) => target.application);
+	for (const target of targets) {
+		const visibleNamespaces = collectVisibleResolverNamespaces(target.application, applications);
+		for (const executor of Object.values(target.application.executorService?.executors ?? {})) if (executor.trigger.kind === "resolverExecuted") {
+			const namespace = findResolverNamespace(target.application, executor.trigger.resolverName) ?? resolveSameRunNamespace(visibleNamespaces, executor.trigger.resolverName, "Resolver");
+			if (namespace && ownerNamespaces.has(namespace)) usedResolvers.add(executor.trigger.resolverName);
+		}
+	}
+	return usedResolvers;
+}
+function collectExpectedLocalStaticWebsiteNames(targets) {
+	const websiteNames = /* @__PURE__ */ new Set();
+	for (const target of targets) for (const website of target.application.staticWebsiteServices) websiteNames.add(website.name);
+	return websiteNames;
+}
+function addPossiblyAmbiguousNamespace(namespaces, key, namespace) {
+	if (namespaces.has(key)) {
+		if (namespaces.get(key) !== namespace) namespaces.set(key, void 0);
+		return;
+	}
+	namespaces.set(key, namespace);
+}
+function collectVisibleResources(params) {
+	const { application, applications, visibleKeysOf, resourcesOf, createResult, addResource } = params;
+	const visibleKeys = visibleKeysOf(application);
+	const result = createResult();
+	for (const candidate of applications) for (const resource of resourcesOf(candidate)) {
+		if (!visibleKeys.has(resource.visibilityKey)) continue;
+		addResource(result, resource.resourceKey, resource.visibilityKey);
+	}
+	return result;
+}
+function collectApplicationTailorDBNamespaces(application) {
+	return /* @__PURE__ */ new Set([...application.tailorDBServices.map((service) => service.namespace), ...application.externalTailorDBNamespaces]);
+}
+function* tailorDBTypeResources(application) {
+	for (const service of application.tailorDBServices) for (const typeName of Object.keys(service.types)) yield {
+		visibilityKey: service.namespace,
+		resourceKey: typeName
+	};
+}
+function collectVisibleTailorDBTypeNamespaces(application, applications) {
+	return collectVisibleResources({
+		application,
+		applications,
+		visibleKeysOf: collectApplicationTailorDBNamespaces,
+		resourcesOf: tailorDBTypeResources,
+		createResult: () => /* @__PURE__ */ new Map(),
+		addResource: addPossiblyAmbiguousNamespace
+	});
+}
+function collectApplicationResolverNamespaces(application) {
+	return new Set(application.subgraphs.filter((subgraph) => subgraph.Type === "pipeline").map((subgraph) => subgraph.Name));
+}
+function* idpNameResources(application) {
+	for (const name of collectApplicationIdpNames(application)) yield {
+		visibilityKey: name,
+		resourceKey: name
+	};
+}
+function collectVisibleIdpNames(application, applications) {
+	return collectVisibleResources({
+		application,
+		applications,
+		visibleKeysOf: collectApplicationIdpNames,
+		resourcesOf: idpNameResources,
+		createResult: () => /* @__PURE__ */ new Set(),
+		addResource: (names, name) => {
+			names.add(name);
+		}
+	});
+}
+function* resolverResources(application) {
+	for (const service of application.resolverServices) for (const resolver of Object.values(service.resolvers)) yield {
+		visibilityKey: service.namespace,
+		resourceKey: resolver.name
+	};
+}
+function collectVisibleResolverNamespaces(application, applications) {
+	return collectVisibleResources({
+		application,
+		applications,
 		visibleKeysOf: collectApplicationResolverNamespaces,
 		resourcesOf: resolverResources,
 		createResult: () => /* @__PURE__ */ new Map(),
@@ -12351,19 +13191,40 @@ function parseDeployConfigPaths(configPath) {
 	if (configPaths.some((entry) => entry.length === 0)) throw new Error("--config must contain one or more non-empty config paths.");
 	return configPaths;
 }
+function recoveryEnvironmentArgs(options, cliContext) {
+	return [
+		...cliContext?.envFile ? ["--env-file", path.resolve(process.cwd(), cliContext.envFile)] : [],
+		...cliContext?.envFileIfExists ? ["--env-file-if-exists", path.resolve(process.cwd(), cliContext.envFileIfExists)] : [],
+		...options?.profile ? ["--profile", options.profile] : []
+	];
+}
+function recoveryOutputArgs(cliContext) {
+	return [...cliContext?.verbose ? ["--verbose"] : [], ...cliContext?.json || logger.jsonMode ? ["--json"] : []];
+}
+function retryDeployArgs(options, configPaths, cliContext) {
+	return [
+		"deploy",
+		"--config",
+		configPaths.join(","),
+		...recoveryEnvironmentArgs(options, cliContext),
+		...options?.dryRun ? ["--dry-run"] : [],
+		...options?.yes ? ["--yes"] : [],
+		...options?.noSchemaCheck ? ["--no-schema-check"] : [],
+		...options?.noValidate ? ["--no-validate"] : [],
+		...options?.noCache ? ["--no-cache"] : [],
+		...options?.cleanCache ? ["--clean-cache"] : [],
+		...recoveryOutputArgs(cliContext)
+	];
+}
+function workspaceRecoveryArgs(options, cliContext) {
+	return [...recoveryEnvironmentArgs(options, cliContext), ...cliContext?.verbose ? ["--verbose"] : []];
+}
 async function buildDeploymentTarget(params) {
-	const { configPath, dryRun, buildOnly, noCache, packageVersion, cacheDir } = params;
-	const { config, plugins } = await withSpan("build.loadConfig", async () => {
-		const foundPath = loadConfigPath(configPath);
-		if (foundPath) {
-			const resolvedPath = path.resolve(process.cwd(), foundPath);
-			if (fs$1.existsSync(resolvedPath)) await ensureConfigIdForDeploy({
-				configPath: resolvedPath,
-				dryRun,
-				buildOnly
-			});
-		}
-		return loadConfig(configPath);
+	const { configPath, loadedConfig, dryRun, buildOnly, noCache, packageVersion, cacheDir } = params;
+	const { config, plugins } = loadedConfig ?? await loadDeployConfig({
+		configPath,
+		dryRun,
+		buildOnly
 	});
 	const configDir = path.dirname(config.path);
 	const lockfilePath = findUpSync("pnpm-lock.yaml", { cwd: configDir }) ?? findUpSync("package-lock.json", { cwd: configDir }) ?? findUpSync("yarn.lock", { cwd: configDir }) ?? findUpSync("bun.lock", { cwd: configDir });
@@ -12404,11 +13265,27 @@ async function buildDeploymentTarget(params) {
 		bundledScripts
 	};
 }
+async function loadDeployConfig(params) {
+	const { configPath, dryRun, buildOnly } = params;
+	return withSpan("build.loadConfig", async () => {
+		const foundPath = loadConfigPath(configPath);
+		if (foundPath) {
+			const resolvedPath = path.resolve(process.cwd(), foundPath);
+			if (fs$1.existsSync(resolvedPath)) await ensureConfigIdForDeploy({
+				configPath: resolvedPath,
+				dryRun,
+				buildOnly
+			});
+		}
+		return loadConfig(configPath);
+	});
+}
 async function buildDeploymentTargets(params) {
-	const { configPaths, buildTarget = buildDeploymentTarget, ...targetParams } = params;
-	return Promise.all(configPaths.map((configPath) => buildTarget({
+	const { configPaths, loadedConfigs, buildTarget = buildDeploymentTarget, ...targetParams } = params;
+	return Promise.all(configPaths.map((configPath, index) => buildTarget({
 		...targetParams,
-		configPath
+		configPath,
+		loadedConfig: loadedConfigs?.[index]
 	})));
 }
 function setBundledScript(target, name, code, kind) {
@@ -12987,16 +13864,41 @@ async function validateDeploymentPlans(deployments) {
 }
 /**
 * Deploy the configured application to the Tailor platform.
-* @param options - Options for deploy execution
+* @param options - Deploy execution options
+* @param cliContext - Global CLI arguments to preserve in recovery actions
 * @returns Promise that resolves to `{ bundledScripts }` when `buildOnly` is true, otherwise void
 */
-async function deploy(options) {
+async function deployInternal(options, cliContext) {
 	return withSpan("deploy", async (rootSpan) => {
 		rootSpan.setAttribute("deploy.dry_run", options?.dryRun ?? false);
 		const configPaths = parseDeployConfigPaths(options?.configPath);
-		const { targets, buildOnly } = await withSpan("build", async () => {
-			const dryRun = options?.dryRun ?? false;
-			const buildOnly = options?.buildOnly ?? parseBoolean(process.env.TAILOR_PLATFORM_SDK_BUILD_ONLY) === true;
+		const dryRun = options?.dryRun ?? false;
+		const buildOnly = options?.buildOnly ?? parseBoolean(process.env.TAILOR_PLATFORM_SDK_BUILD_ONLY) === true;
+		const preflightConfigs = buildOnly ? [] : await withSpan("config.preflight", () => Promise.all(configPaths.map((configPath) => loadDeployConfig({
+			configPath,
+			dryRun,
+			buildOnly
+		}))));
+		const resolvedConfigPaths = preflightConfigs.map(({ config }) => config.path);
+		const workspaceContextTargets = preflightConfigs.map(({ config }) => ({
+			configPath: config.path,
+			applicationId: config.id ?? `name:${config.name}`
+		}));
+		const workspace = buildOnly ? void 0 : await resolveDeployWorkspace({
+			workspaceId: options?.workspaceId,
+			profile: options?.profile,
+			createWorkspace: options?.createWorkspace,
+			workspaceName: options?.workspaceName,
+			workspaceRegion: options?.workspaceRegion,
+			organizationId: options?.organizationId,
+			folderId: options?.folderId,
+			dryRun,
+			contextTargets: workspaceContextTargets,
+			deployArgs: retryDeployArgs(options, resolvedConfigPaths, cliContext),
+			workspaceCommandArgs: workspaceRecoveryArgs(options, cliContext),
+			workspaceCommandJson: cliContext?.json || logger.jsonMode
+		});
+		const targets = await withSpan("build", async () => {
 			const noCache = options?.noCache ?? false;
 			const packageJson = await readPackageJson();
 			const cacheDir = path.resolve(getDistDir(), "cache");
@@ -13007,25 +13909,20 @@ async function deploy(options) {
 				});
 				logger.info("Bundle cache cleaned");
 			}
-			return {
-				targets: await buildDeploymentTargets({
-					configPaths,
-					dryRun,
-					buildOnly,
-					noCache,
-					packageVersion: packageJson.version ?? "unknown",
-					cacheDir
-				}),
-				buildOnly
-			};
+			return await buildDeploymentTargets({
+				configPaths,
+				loadedConfigs: preflightConfigs,
+				dryRun,
+				buildOnly,
+				noCache,
+				packageVersion: packageJson.version ?? "unknown",
+				cacheDir
+			});
 		});
 		if (buildOnly) return { bundledScripts: mergeBundledScripts(targets) };
 		assertUniqueGlobalResourceNames(targets);
-		const client = await initOperatorClient(await loadAccessToken({ profile: options?.profile }));
-		const workspaceId = await loadWorkspaceId({
-			workspaceId: options?.workspaceId,
-			profile: options?.profile
-		});
+		if (!workspace) throw new Error("Workspace was not resolved");
+		const { client, workspaceId } = workspace;
 		rootSpan.setAttribute("app.name", targets.map((target) => target.application.name).join(","));
 		rootSpan.setAttribute("workspace.id", workspaceId);
 		const deployments = await planDeploymentTargets({
@@ -13035,7 +13932,6 @@ async function deploy(options) {
 			workspaceId,
 			noSchemaCheck: options?.noSchemaCheck
 		});
-		const dryRun = options?.dryRun ?? false;
 		const yes = options?.yes ?? false;
 		dropCrossDeploymentManagedDeletes(deployments);
 		await withSpan("confirm", async () => {
@@ -13059,6 +13955,23 @@ async function deploy(options) {
 		else logger.success("Successfully applied changes.");
 	});
 }
+/**
+* Deploy using the programmatic CLI API.
+* @param options - Deploy execution options
+* @returns Deploy result
+*/
+function deploy(options) {
+	return deployInternal(options);
+}
+/**
+* Deploy from the command adapter while preserving global CLI arguments in recovery actions.
+* @param options - Deploy execution options
+* @param cliContext - Global CLI arguments already applied by the command runner
+* @returns Deploy result
+*/
+function deployFromCLI(options, cliContext) {
+	return deployInternal(options, cliContext);
+}
 
 //#endregion
 //#region src/cli/commands/executor/status.ts
@@ -13448,52 +14361,6 @@ const getCommand$6 = defineAppCommand({
 	}
 });
 
-//#endregion
-//#region src/cli/shared/format.ts
-/**
-* Format a protobuf Timestamp to ISO string.
-* @param timestamp - Protobuf timestamp
-* @returns Date object or null if invalid
-*/
-function formatTimestamp(timestamp) {
-	if (!timestamp) return null;
-	const date = timestampDate(timestamp);
-	if (Number.isNaN(date.getTime())) return null;
-	return date;
-}
-/**
-* Formats a table with consistent single-line border style.
-* Use this instead of importing `table` directly.
-* @param data - Table data
-* @param config - Table configuration
-* @returns Formatted table string
-*/
-function formatTable(data, config) {
-	return table(data, {
-		...config,
-		border: getBorderCharacters("norc")
-	});
-}
-/**
-* Formats a key-value table with single-line border style.
-* @param data - Key-value pairs
-* @returns Formatted key-value table string
-*/
-function formatKeyValueTable(data) {
-	return formatTable(data, { singleLine: true });
-}
-/**
-* Format a Date or ISO timestamp string as a human-readable relative time.
-* @param value - Date object, ISO date string, or null
-* @returns Relative time (e.g., "5 minutes ago") or "N/A" for null/invalid
-*/
-function humanizeRelativeTime(value) {
-	if (value === null) return "N/A";
-	const date = value instanceof Date ? value : new Date(value);
-	if (Number.isNaN(date.getTime())) return typeof value === "string" ? value : "N/A";
-	return formatDistanceToNowStrict(date, { addSuffix: true });
-}
-
 //#endregion
 //#region src/cli/shared/function-execution.ts
 /**
@@ -14892,7 +15759,7 @@ async function listExecutors(options) {
 		return [executors, nextPageToken];
 	}, { limit: options?.limit })).map((e) => toExecutorListInfo(e));
 }
-const listCommand$9 = defineAppCommand({
+const listCommand$8 = defineAppCommand({
 	name: "list",
 	description: "List all executors",
 	args: z.object({
@@ -15317,7 +16184,7 @@ async function listFunctionRegistries(options) {
 		}
 	}, { limit })).map(functionRegistryInfo);
 }
-const listCommand$8 = defineAppCommand({
+const listCommand$7 = defineAppCommand({
 	name: "list",
 	description: "List function registries in a workspace",
 	args: z.object({
@@ -16262,7 +17129,7 @@ async function listMachineUsers(options) {
 		return [machineUsers, nextPageToken];
 	}, { limit: options?.limit })).map(machineUserInfo);
 }
-const listCommand$7 = defineAppCommand({
+const listCommand$6 = defineAppCommand({
 	name: "list",
 	description: "List all machine users in the application.",
 	args: z.object({
@@ -16478,7 +17345,7 @@ async function listOAuth2Clients(options) {
 		return [oauth2Clients, nextPageToken];
 	}, { limit: options?.limit })).map(toOAuth2ClientInfo);
 }
-const listCommand$6 = defineAppCommand({
+const listCommand$5 = defineAppCommand({
 	name: "list",
 	description: "List all OAuth2 clients in the application.",
 	args: z.object({
@@ -16548,7 +17415,7 @@ async function createFolder(options) {
 	if (!response.folder) throw new Error("Failed to create folder.");
 	return folderInfo(response.folder);
 }
-const createCommand$1 = defineAppCommand({
+const createCommand = defineAppCommand({
 	name: "create",
 	description: "Create a new folder in an organization.",
 	args: z.object({
@@ -16696,7 +17563,7 @@ async function listFolders(options) {
 		return [response.folders, response.nextPageToken];
 	}, { limit })).map(folderListInfo);
 }
-const listCommand$5 = defineAppCommand({
+const listCommand$4 = defineAppCommand({
 	name: "list",
 	description: "List folders in an organization.",
 	args: z.object({
@@ -16805,7 +17672,7 @@ async function listOrganizations(options) {
 	if (limit !== void 0) return results.slice(0, limit);
 	return results;
 }
-const listCommand$4 = defineAppCommand({
+const listCommand$3 = defineAppCommand({
 	name: "list",
 	description: "List organizations you belong to.",
 	args: z.object({ limit: arg(positiveIntArg.optional(), {
@@ -17095,141 +17962,63 @@ const removeCommand$1 = defineAppCommand({
 			profile: args.profile,
 			configPath: args.config
 		});
-		logger.info(`Planning removal of resources managed by "${application.name}"...`);
-		logger.newline();
-		await execRemove(client, workspaceId, application, config, async () => {
-			if (!args.yes) {
-				if (!await prompt.confirm({
-					message: "Are you sure you want to remove all resources?",
-					default: false
-				})) throw new Error(multiline`
-        Remove cancelled. No resources were deleted.
-        To override, run again and confirm, or use --yes flag.
-      `);
-			} else logger.success("Removing all resources (--yes flag specified)...");
-		});
-		logger.success(`Successfully removed all resources managed by "${application.name}".`);
-	}
-});
-
-//#endregion
-//#region src/cli/shared/beta.ts
-/**
-* Warn that a feature is in beta.
-* @param {string} featureName - Name of the beta feature (e.g., "tailordb erd", "tailordb migration")
-*/
-function logBetaWarning(featureName) {
-	logger.warn(`The '${featureName}' command is a beta feature and may introduce breaking changes in future releases.`);
-	logger.newline();
-}
-
-//#endregion
-//#region src/cli/shared/config.ts
-/**
-* Extracts every namespace key declared under `config.db`, including those
-* declared with `{ external: true }`.
-* @param config - Loaded application configuration.
-* @returns Namespace names in insertion order.
-*/
-function extractAllNamespaces(config) {
-	const namespaces = /* @__PURE__ */ new Set();
-	if (config.db) for (const namespaceName of Object.keys(config.db)) namespaces.add(namespaceName);
-	return Array.from(namespaces);
-}
-/**
-* Extracts namespace keys under `config.db` that this app owns
-* (i.e. not declared with `{ external: true }`). Use this for destructive
-* operations like `tailordb truncate --all` to avoid touching namespaces
-* owned by other apps.
-* @param config - Loaded application configuration.
-* @returns Owned namespace names in insertion order.
-*/
-function extractOwnedNamespaces(config) {
-	const namespaces = /* @__PURE__ */ new Set();
-	if (config.db) for (const [namespaceName, nsConfig] of Object.entries(config.db)) {
-		if ("external" in nsConfig) continue;
-		namespaces.add(namespaceName);
-	}
-	return Array.from(namespaces);
-}
-
-//#endregion
-//#region src/cli/commands/workspace/transform.ts
-const workspaceInfo = (workspace, folderName) => {
-	const info = {
-		id: workspace.id,
-		name: workspace.name,
-		region: workspace.region,
-		createdAt: formatTimestamp(workspace.createTime),
-		updatedAt: formatTimestamp(workspace.updateTime)
-	};
-	return folderName ? {
-		...info,
-		folderName
-	} : info;
-};
-const workspaceDetails = (workspace, folderName) => {
-	return {
-		...workspaceInfo(workspace, folderName),
-		deleteProtection: workspace.deleteProtection,
-		organizationId: workspace.organizationId,
-		folderId: workspace.folderId
-	};
-};
-async function resolveWorkspaceFolderName(client, workspace) {
-	if (!workspace.organizationId || !workspace.folderId) return void 0;
-	try {
-		return (await client.getOrganizationFolder({
-			organizationId: workspace.organizationId,
-			folderId: workspace.folderId
-		})).folder?.name || void 0;
-	} catch (error) {
-		if (error instanceof ConnectError && (error.code === Code.NotFound || error.code === Code.PermissionDenied)) return;
-		logger.warn(`Failed to resolve workspace folder name: ${error}`);
-		return;
-	}
-}
-function createWorkspaceFolderNameResolver(client) {
-	const cache = /* @__PURE__ */ new Map();
-	return (workspace) => {
-		if (!workspace.organizationId || !workspace.folderId) return Promise.resolve(void 0);
-		const cacheKey = `${workspace.organizationId}/${workspace.folderId}`;
-		const cached = cache.get(cacheKey);
-		if (cached) return cached;
-		const promise = resolveWorkspaceFolderName(client, workspace);
-		cache.set(cacheKey, promise);
-		return promise;
-	};
-}
-async function workspaceInfoWithFolderName(client, workspace) {
-	const folderName = await resolveWorkspaceFolderName(client, workspace);
-	return workspaceInfo(workspace, folderName);
-}
-async function workspaceDetailsWithFolderName(client, workspace) {
-	const folderName = await resolveWorkspaceFolderName(client, workspace);
-	return workspaceDetails(workspace, folderName);
-}
-async function workspaceInfosWithFolderNames(client, workspaces) {
-	const resolveFolderName = createWorkspaceFolderNameResolver(client);
-	const limit = pLimit(5);
-	return Promise.all(workspaces.map((workspace) => limit(async () => workspaceInfo(workspace, await resolveFolderName(workspace)))));
+		logger.info(`Planning removal of resources managed by "${application.name}"...`);
+		logger.newline();
+		await execRemove(client, workspaceId, application, config, async () => {
+			if (!args.yes) {
+				if (!await prompt.confirm({
+					message: "Are you sure you want to remove all resources?",
+					default: false
+				})) throw new Error(multiline`
+        Remove cancelled. No resources were deleted.
+        To override, run again and confirm, or use --yes flag.
+      `);
+			} else logger.success("Removing all resources (--yes flag specified)...");
+		});
+		logger.success(`Successfully removed all resources managed by "${application.name}".`);
+	}
+});
+
+//#endregion
+//#region src/cli/shared/beta.ts
+/**
+* Warn that a feature is in beta.
+* @param {string} featureName - Name of the beta feature (e.g., "tailordb erd", "tailordb migration")
+*/
+function logBetaWarning(featureName) {
+	logger.warn(`The '${featureName}' command is a beta feature and may introduce breaking changes in future releases.`);
+	logger.newline();
 }
-function workspaceDisplayName(workspace) {
-	return workspace.folderName ? `${workspace.folderName}/${workspace.name}` : workspace.name;
+
+//#endregion
+//#region src/cli/shared/config.ts
+/**
+* Extracts every namespace key declared under `config.db`, including those
+* declared with `{ external: true }`.
+* @param config - Loaded application configuration.
+* @returns Namespace names in insertion order.
+*/
+function extractAllNamespaces(config) {
+	const namespaces = /* @__PURE__ */ new Set();
+	if (config.db) for (const namespaceName of Object.keys(config.db)) namespaces.add(namespaceName);
+	return Array.from(namespaces);
 }
-function createWorkspaceNameTransformer(nameKey, folderNameKey) {
-	return (value, item) => {
-		const workspace = item;
-		const name = workspace[nameKey];
-		const folderName = workspace[folderNameKey];
-		if (typeof name === "string" && typeof folderName === "string") return workspaceDisplayName({
-			name,
-			folderName
-		});
-		return String(value ?? "");
-	};
+/**
+* Extracts namespace keys under `config.db` that this app owns
+* (i.e. not declared with `{ external: true }`). Use this for destructive
+* operations like `tailordb truncate --all` to avoid touching namespaces
+* owned by other apps.
+* @param config - Loaded application configuration.
+* @returns Owned namespace names in insertion order.
+*/
+function extractOwnedNamespaces(config) {
+	const namespaces = /* @__PURE__ */ new Set();
+	if (config.db) for (const [namespaceName, nsConfig] of Object.entries(config.db)) {
+		if ("external" in nsConfig) continue;
+		namespaces.add(namespaceName);
+	}
+	return Array.from(namespaces);
 }
-const workspaceNameTransformer = createWorkspaceNameTransformer("name", "folderName");
 
 //#endregion
 //#region src/cli/commands/show.ts
@@ -17246,10 +18035,27 @@ function applicationInfo(app) {
 		updatedAt: app.updateTime ? timestampDate(app.updateTime) : null
 	};
 }
+async function fetchAIGateways(client, workspaceId, names) {
+	return (await Promise.all(names.map(async (name) => {
+		try {
+			const { aigateway } = await client.getAIGateway({
+				workspaceId,
+				aigatewayName: name
+			});
+			return aigateway ? {
+				name: aigateway.name,
+				url: aigateway.url
+			} : void 0;
+		} catch (error) {
+			if (error instanceof ConnectError && error.code === Code.NotFound) return;
+			throw error;
+		}
+	}))).filter((gateway) => gateway !== void 0);
+}
 /**
 * Show applied application information for the current workspace.
 * @param options - Show options
-* @returns Application information
+* @returns Deployed application, workspace, and AI Gateway information
 */
 async function show(options) {
 	const client = await initOperatorClient(await loadAccessToken({ profile: options?.profile }));
@@ -17258,10 +18064,15 @@ async function show(options) {
 		profile: options?.profile
 	});
 	const { config } = await loadConfig(options?.configPath);
-	const [workspaceResp, resp] = await Promise.all([client.getWorkspace({ workspaceId }), client.getApplication({
-		workspaceId,
-		applicationName: config.name
-	})]);
+	const aiGatewayNames = config.aiGateways?.length ? [...new Set(config.aiGateways.map((gateway) => gateway.name))] : [];
+	const [workspaceResp, resp, aiGateways] = await Promise.all([
+		client.getWorkspace({ workspaceId }),
+		client.getApplication({
+			workspaceId,
+			applicationName: config.name
+		}),
+		fetchAIGateways(client, workspaceId, aiGatewayNames)
+	]);
 	const { name, ...appInfo } = applicationInfo(assertDefined(resp.application, `application "${config.name}" not found in workspace`));
 	const workspace = workspaceResp.workspace;
 	const workspaceFolderName = workspace ? await resolveWorkspaceFolderName(client, workspace) : "";
@@ -17271,7 +18082,8 @@ async function show(options) {
 		workspaceName: workspace?.name ?? "",
 		...workspaceFolderName ? { workspaceFolderName } : {},
 		workspaceRegion: workspace?.region ?? "",
-		...appInfo
+		...appInfo,
+		aiGateways
 	};
 }
 const showWorkspaceNameTransformer = createWorkspaceNameTransformer("workspaceName", "workspaceFolderName");
@@ -17878,7 +18690,7 @@ async function generate(options) {
 	if (options.init) await handleInitOption(namespacesWithMigrations, options.yes);
 	let pluginManager;
 	if (plugins.length > 0) pluginManager = new PluginManager(plugins);
-	const { defineApplication } = await import("./application-6zsDLGKv.mjs");
+	const { defineApplication } = await import("./application-BB6BlUfk.mjs");
 	const application = defineApplication({
 		config,
 		pluginManager
@@ -18238,7 +19050,7 @@ async function listWorkflows(options) {
 		return [workflows, nextPageToken];
 	}, { limit: options?.limit })).map(toWorkflowListInfo);
 }
-const listCommand$3 = defineAppCommand({
+const listCommand$2 = defineAppCommand({
 	name: "list",
 	description: "List all workflows in the workspace.",
 	args: z.object({
@@ -18571,7 +19383,7 @@ async function listApps(options) {
 		return [applications, nextPageToken];
 	}, { limit })).map(appInfo);
 }
-const listCommand$2 = defineAppCommand({
+const listCommand$1 = defineAppCommand({
 	name: "list",
 	description: "List applications in a workspace",
 	args: z.object({
@@ -18594,152 +19406,6 @@ const listCommand$2 = defineAppCommand({
 	}
 });
 
-//#endregion
-//#region src/cli/commands/workspace/create.ts
-/**
-* Schema for workspace creation options
-* - name: 3-63 chars, lowercase alphanumeric and hyphens, cannot start/end with hyphen
-* - organizationId, folderId: optional UUIDs
-*/
-const createWorkspaceOptionsSchema = z.object({
-	name: z.string().min(3, "Name must be at least 3 characters").max(63, "Name must be at most 63 characters").regex(/^[a-z0-9-]+$/, "Name can only contain lowercase letters, numbers, and hyphens").refine((n) => !n.startsWith("-") && !n.endsWith("-"), "Name cannot start or end with a hyphen"),
-	region: z.string(),
-	deleteProtection: z.boolean().optional(),
-	organizationId: z.uuid().optional(),
-	folderId: z.uuid().optional()
-});
-const validateRegion = async (region, client) => {
-	const availableRegions = await client.listAvailableWorkspaceRegions({});
-	if (!availableRegions.regions.includes(region)) throw new Error(`Region must be one of: ${availableRegions.regions.join(", ")}.`);
-};
-function profilePlatformSettings(platformConfig) {
-	const hasOAuth2ClientId = platformConfig?.oauth2ClientId || process.env.TAILOR_PLATFORM_OAUTH2_CLIENT_ID;
-	const hasConsoleUrl = platformConfig?.consoleUrl || process.env.TAILOR_PLATFORM_CONSOLE_URL;
-	return {
-		...isDefaultPlatform(platformConfig) ? {} : { platform_url: getPlatformBaseUrl(platformConfig) },
-		...hasOAuth2ClientId ? { oauth2_client_id: getOAuth2ClientId(platformConfig) } : {},
-		...hasConsoleUrl ? { console_url: getConsoleBaseUrl(platformConfig) } : {}
-	};
-}
-/**
-* Create a new workspace with the given options.
-* @param options - Workspace creation options
-* @returns Created workspace info
-*/
-async function createWorkspace(options) {
-	const result = createWorkspaceOptionsSchema.safeParse(options);
-	if (!result.success) throw new Error(assertDefined(result.error.issues[0], "Zod returned no issues").message);
-	const validated = result.data;
-	const client = await initOperatorClient(await loadAccessToken());
-	await validateRegion(validated.region, client);
-	return workspaceInfoWithFolderName(client, assertDefined((await client.createWorkspace({
-		workspaceName: validated.name,
-		workspaceRegion: validated.region,
-		deleteProtection: validated.deleteProtection ?? false,
-		organizationId: validated.organizationId,
-		folderId: validated.folderId
-	})).workspace, "createWorkspace response missing workspace"));
-}
-const createCommand = defineAppCommand({
-	name: "create",
-	description: "Create a new Tailor Platform workspace.",
-	args: z.object({
-		name: arg(z.string(), {
-			alias: "n",
-			description: "Workspace name"
-		}),
-		region: arg(z.string(), {
-			alias: "r",
-			description: "Workspace region (us-west, asia-northeast)"
-		}),
-		"delete-protection": arg(z.boolean().default(false), {
-			alias: "d",
-			description: "Enable delete protection"
-		}),
-		"organization-id": arg(z.string().optional(), {
-			alias: "o",
-			description: "Organization ID to workspace associate with",
-			env: "TAILOR_PLATFORM_ORGANIZATION_ID"
-		}),
-		"folder-id": arg(z.string().optional(), {
-			alias: "f",
-			description: "Folder ID to workspace associate with",
-			env: "TAILOR_PLATFORM_FOLDER_ID"
-		}),
-		"profile-name": arg(z.string().optional(), {
-			alias: "p",
-			description: "Profile name to create"
-		}),
-		"profile-user": arg(z.string().optional(), { description: "User email for the profile (defaults to current user)" }),
-		permission: arg(z.enum(["write", "read"]).default("write"), { description: "Profile permission (requires --profile-name). 'read' blocks all write commands while the profile is active." })
-	}).strict(),
-	run: async (args) => {
-		await assertWritable();
-		const profileName = args["profile-name"];
-		let profileSetup;
-		if (profileName) {
-			const config = await readPlatformConfig();
-			if (config.profiles[profileName]) throw new Error(`Profile "${profileName}" already exists.`);
-			const activeProfileName = process.env.TAILOR_PLATFORM_PROFILE;
-			const activeProfileEntry = activeProfileName ? config.profiles[activeProfileName] : void 0;
-			const platformConfig = activeProfileEntry ? platformConfigFromProfile(activeProfileEntry) : void 0;
-			const profileUser = args["profile-user"] || activeProfileEntry?.user || config.current_user;
-			if (!profileUser) throw new Error("Current user not found. Please login or specify --profile-user to create a profile.");
-			if (!hasUserTokenEntry(config, profileUser, platformConfig)) throw new Error(`User "${profileUser}" not found.\nPlease verify your user name and login using 'tailor-sdk login' command.`);
-			profileSetup = {
-				name: profileName,
-				user: profileUser,
-				platformSettings: profilePlatformSettings(platformConfig)
-			};
-		}
-		const workspace = await createWorkspace({
-			name: args.name,
-			region: args.region,
-			deleteProtection: args["delete-protection"],
-			organizationId: args["organization-id"],
-			folderId: args["folder-id"]
-		});
-		let profileInfo;
-		if (profileSetup) {
-			const config = await readPlatformConfig();
-			const platformSettings = profileSetup.platformSettings;
-			config.profiles[profileSetup.name] = {
-				user: profileSetup.user,
-				workspace_id: workspace.id,
-				...args.permission === "read" ? { readonly: true } : {},
-				...platformSettings
-			};
-			writePlatformConfig(config);
-			profileInfo = {
-				name: profileSetup.name,
-				user: profileSetup.user,
-				workspaceId: workspace.id,
-				permission: args.permission,
-				...platformSettings.platform_url ? { platformUrl: platformSettings.platform_url } : {},
-				...platformSettings.oauth2_client_id ? { oauth2ClientId: platformSettings.oauth2_client_id } : {},
-				...platformSettings.console_url ? { consoleUrl: platformSettings.console_url } : {}
-			};
-			if (!args.json) logger.success(`Profile "${profileSetup.name}" created successfully.`);
-		}
-		if (!args.json) logger.success(`Workspace "${workspaceDisplayName(workspace)}" created successfully.`);
-		if (args.json && profileInfo) {
-			logger.out({
-				...workspace,
-				profile: profileInfo
-			});
-			return;
-		}
-		logger.out(workspace, { display: {
-			name: workspaceNameTransformer,
-			folderName: null
-		} });
-		if (profileInfo) {
-			logger.out("Profile:");
-			logger.out(profileInfo);
-		}
-	}
-});
-
 //#endregion
 //#region src/cli/commands/workspace/delete.ts
 const deleteWorkspaceOptionsSchema = z.object({ workspaceId: z.uuid({ message: "workspace-id must be a valid UUID" }) });
@@ -18853,42 +19519,6 @@ const getCommand = defineAppCommand({
 	}
 });
 
-//#endregion
-//#region src/cli/commands/workspace/list.ts
-/**
-* List workspaces with an optional order and limit.
-* @param options - Workspace listing options
-* @returns List of workspaces
-*/
-async function listWorkspaces(options) {
-	const client = await initOperatorClient(await loadAccessToken());
-	const pageDirection = toPageDirection(options?.order);
-	return workspaceInfosWithFolderNames(client, await fetchPaged(async (pageToken, pageSize) => {
-		const { workspaces, nextPageToken } = await client.listWorkspaces({
-			pageToken,
-			pageSize,
-			pageDirection
-		});
-		return [workspaces, nextPageToken];
-	}, { limit: options?.limit }));
-}
-const listCommand$1 = defineAppCommand({
-	name: "list",
-	description: "List all Tailor Platform workspaces.",
-	args: z.object({ ...paginationArgs() }).strict(),
-	run: async (args) => {
-		const workspaces = await listWorkspaces({
-			order: args.order,
-			limit: args.limit
-		});
-		logger.out(workspaces, { display: {
-			name: workspaceNameTransformer,
-			folderName: null,
-			updatedAt: null
-		} });
-	}
-});
-
 //#endregion
 //#region src/cli/commands/workspace/restore.ts
 const restoreWorkspaceOptionsSchema = z.object({ workspaceId: z.uuid({ message: "workspace-id must be a valid UUID" }) });
@@ -20145,5 +20775,5 @@ function isDeno() {
 }
 
 //#endregion
-export { getOrganization as $, multiConfigArg as $n, compareSnapshotWithRemote as $t, listCommand$3 as A, apiCall as An, getExecutorWaitFailureMessage as At, show as B, loadStoredUserTokens as Bn, listWorkflowExecutions as Bt, listCommand$2 as C, hasChanges as Cn, listWebhookExecutors as Ct, waitWorkflowExecution as D, PluginManager as Dn, listCommand$9 as Dt, waitCommand as E, sdkNameLabelKey as En, triggerExecutor as Et, generateCommand as F, hasAnyUserTokenEntry as Fn, startWorkflow as Ft, removeCommand$1 as G, saveUserTokens as Gn, deploy as Gt, extractOwnedNamespaces as H, platformConfigFromProfile as Hn, formatKeyValueTable as Ht, generateMigrationScript as I, hasUserTokenEntry as In, getCommand$5 as It, organizationTree as J, commonArgs as Jn, waitForExecution as Jt, updateCommand$1 as K, writePlatformConfig as Kn, ensureConfigId as Kt, writeDbTypesFile as L, loadAccessToken as Ln, getWorkflow as Lt, truncate as M, loadConfig as Mn, listExecutorJobs as Mt, truncateCommand as N, deleteUserTokens as Nn, watchExecutorJob as Nt, resumeCommand as O, generateUserTypes as On, listExecutors as Ot, generate as P, fetchLatestToken as Pn, startCommand as Pt, getCommand$1 as Q, isVerbose as Qn, parseMigrationLabelNumber as Qt, getConfiguredEditorCommand as R, loadConsoleBaseUrl as Rn, executionsCommand as Rt, listApps as S, formatMigrationDiff as Sn, getFunctionRegistry as St, healthCommand as T, resourceTrn as Tn, triggerCommand as Tt, logBetaWarning as U, readPlatformConfig as Un, getCommand$6 as Ut, showCommand as V, loadWorkspaceId as Vn, functionExecutionStatusToString as Vt, remove as W, resolveUserTokenKey as Wn, getExecutor as Wt, listCommand$4 as X, confirmationArgs as Xn, MIGRATION_LABEL_KEY as Xt, treeCommand as Y, configArg as Yn, bundleMigrationScript as Yt, listOrganizations as Z, deploymentArgs as Zn, handleOptionalToRequiredError as Zt, getWorkspace as _, loadDiff as _n, listMachineUsers as _t, updateUser as a, MIGRATE_FILE_NAME as an, getFolder as at, createCommand as b, parseMigrationNumberArg as bn, listFunctionRegistries as bt, listCommand as c, compareLocalTypesWithSnapshot as cn, createCommand$1 as ct, inviteUser as d, getLatestMigrationNumber as dn, listOAuth2Clients as dt, generateAllTypeManifestsFromSnapshot as en, pagedLogArgs as er, updateCommand$2 as et, restoreCommand as f, getMigrationDirPath as fn, getCommand$3 as ft, getCommand as g, isValidMigrationNumber as gn, listCommand$7 as gt, listWorkspaces as h, getNextMigrationNumber as hn, tokenCommand as ht, updateCommand as i, INITIAL_SCHEMA_NUMBER as in, workspaceArgs as ir, getCommand$2 as it, listWorkflows as j, assertWritable as jn, jobsCommand as jt, resumeWorkflow as k, prompt as kn, getExecutorJob as kt, listUsers as l, compareSnapshots as ln, createFolder as lt, listCommand$1 as m, getMigrationFiles as mn, getMachineUserToken as mt, query as n, DB_TYPES_FILE_NAME as nn, resolveMachineUserInputSource as nr, listCommand$5 as nt, removeCommand as o, SCHEMA_FILE_NAME as on, deleteCommand$1 as ot, restoreWorkspace as p, getMigrationFilePath as pn, getOAuth2Client as pt, updateOrganization as q, defineAppCommand as qn, executeScript as qt, queryCommand as r, DIFF_FILE_NAME as rn, toPageDirection as rr, listFolders as rt, removeUser as s, assertValidMigrationFiles as sn, deleteFolder as st, isNativeTypeScriptRuntime as t, protoGqlPermission as tn, paginationArgs as tr, updateFolder as tt, inviteCommand as u, createSnapshotFromLocalTypes as un, listCommand$6 as ut, deleteCommand as v, reconstructSnapshotFromMigrations as vn, generate$1 as vt, getAppHealth as w, getNamespacesWithMigrations as wn, webhookCommand as wt, createWorkspace as x, formatDiffSummary as xn, getCommand$4 as xt, deleteWorkspace as y, formatMigrationNumber as yn, listCommand$8 as yt, openInConfiguredEditor as z, loadMachineUserName as zn, getWorkflowExecution as zt };
-//# sourceMappingURL=runtime-DlklyuHN.mjs.map
+export { listFolders as $, deploymentArgs as $n, handleOptionalToRequiredError as $t, generate as A, generateUserTypes as An, startCommand as At, remove as B, loadConsoleBaseUrl as Bn, deploy as Bt, waitWorkflowExecution as C, formatDiffSummary as Cn, listCommand$8 as Ct, listWorkflows as D, resourceTrn as Dn, jobsCommand as Dt, listCommand$2 as E, getNamespacesWithMigrations as En, getExecutorWaitFailureMessage as Et, openInConfiguredEditor as F, deleteUserTokens as Fn, getWorkflowExecution as Ft, treeCommand as G, readPlatformConfig as Gn, createWorkspace$1 as Gt, updateCommand$1 as H, loadStoredUserTokens as Hn, listCommand$9 as Ht, show as I, fetchLatestToken as In, listWorkflowExecutions as It, getCommand$1 as J, writePlatformConfig as Jn, ensureConfigId as Jt, listCommand$3 as K, resolveUserTokenKey as Kn, formatKeyValueTable as Kt, showCommand as L, hasAnyUserTokenEntry as Ln, functionExecutionStatusToString as Lt, generateMigrationScript as M, apiCall as Mn, getCommand$5 as Mt, writeDbTypesFile as N, assertWritable as Nn, getWorkflow as Nt, truncate as O, sdkNameLabelKey as On, listExecutorJobs as Ot, getConfiguredEditorCommand as P, loadConfig as Pn, executionsCommand as Pt, listCommand$4 as Q, confirmationArgs as Qn, MIGRATION_LABEL_KEY as Qt, extractOwnedNamespaces as R, hasUserTokenEntry as Rn, getCommand$6 as Rt, waitCommand as S, parseMigrationNumberArg as Sn, triggerExecutor as St, resumeWorkflow as T, hasChanges as Tn, getExecutorJob as Tt, updateOrganization as U, loadWorkspaceId as Un, listWorkspaces as Ut, removeCommand$1 as V, loadMachineUserName as Vn, deployFromCLI as Vt, organizationTree as W, platformConfigFromProfile as Wn, createCommand$1 as Wt, updateCommand$2 as X, commonArgs as Xn, waitForExecution as Xt, getOrganization as Y, defineAppCommand as Yn, executeScript as Yt, updateFolder as Z, configArg as Zn, bundleMigrationScript as Zt, deleteWorkspace as _, getNextMigrationNumber as _n, getCommand$4 as _t, updateUser as a, DIFF_FILE_NAME as an, toPageDirection as ar, createFolder as at, getAppHealth as b, reconstructSnapshotFromMigrations as bn, webhookCommand as bt, listCommand as c, SCHEMA_FILE_NAME as cn, getCommand$3 as ct, inviteUser as d, compareSnapshots as dn, tokenCommand as dt, parseMigrationLabelNumber as en, isVerbose as er, getCommand$2 as et, restoreCommand as f, createSnapshotFromLocalTypes as fn, listCommand$6 as ft, deleteCommand as g, getMigrationFiles as gn, listFunctionRegistries as gt, getWorkspace as h, getMigrationFilePath as hn, listCommand$7 as ht, updateCommand as i, DB_TYPES_FILE_NAME as in, resolveMachineUserInputSource as ir, createCommand as it, generateCommand as j, prompt as jn, startWorkflow as jt, truncateCommand as k, PluginManager as kn, watchExecutorJob as kt, listUsers as l, assertValidMigrationFiles as ln, getOAuth2Client as lt, getCommand as m, getMigrationDirPath as mn, generate$1 as mt, query as n, generateAllTypeManifestsFromSnapshot as nn, pagedLogArgs as nr, deleteCommand$1 as nt, removeCommand as o, INITIAL_SCHEMA_NUMBER as on, workspaceArgs as or, listCommand$5 as ot, restoreWorkspace as p, getLatestMigrationNumber as pn, listMachineUsers as pt, listOrganizations as q, saveUserTokens as qn, workspaceNameSchema as qt, queryCommand as r, protoGqlPermission as rn, paginationArgs as rr, deleteFolder as rt, removeUser as s, MIGRATE_FILE_NAME as sn, listOAuth2Clients as st, isNativeTypeScriptRuntime as t, compareSnapshotWithRemote as tn, multiConfigArg as tr, getFolder as tt, inviteCommand as u, compareLocalTypesWithSnapshot as un, getMachineUserToken as ut, listApps as v, isValidMigrationNumber as vn, getFunctionRegistry as vt, resumeCommand as w, formatMigrationDiff as wn, listExecutors as wt, healthCommand as x, formatMigrationNumber as xn, triggerCommand as xt, listCommand$1 as y, loadDiff as yn, listWebhookExecutors as yt, logBetaWarning as z, loadAccessToken as zn, getExecutor as zt };
+//# sourceMappingURL=runtime-CjMeYuPA.mjs.map