@tailor-platform/sdk 1.60.3 → 1.62.0

package/dist/cli/index.mjs

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
 
-import { J as PATScope, O as CustomDomainStatus, P as FunctionExecution_Type, V as AuthInvokerSchema, _ as userAgent, a as fetchAll, c as fetchPlatformMachineUserToken, d as initOAuth2Client, f as initOperatorClient, l as fetchUserInfo, r as closeConnectionPool, s as fetchPaged } from "../client-W5P4NYYX.mjs";
+import { Et as AuthInvokerSchema, L as CustomDomainStatus, Nt as PATScope, Q as FunctionExecution_Type, _ as userAgent, a as fetchAll, c as fetchPlatformMachineUserToken, d as initOAuth2Client, f as initOperatorClient, l as fetchUserInfo, r as closeConnectionPool, s as fetchPaged } from "../client-CobIRHl-.mjs";
+import { t as assertDefined } from "../assert-CKfwrmCV.mjs";
 import { n as logger, r as styles } from "../logger-DpJyJvNz.mjs";
-import { $ as listCommand$10, An as toPageDirection, At as startCommand, B as logBetaWarning, C as listCommand$13, Cn as commonArgs, Dn as isVerbose, Dt as jobsCommand, E as resumeCommand, En as deploymentArgs, F as writeDbTypesFile, Gt as parseMigrationLabelNumber, H as removeCommand$1, Ht as executeScript, I as getConfiguredEditorCommand, K as treeCommand, L as openInConfiguredEditor, Lt as functionExecutionStatusToString, Mt as getCommand$6, N as generateCommand$1, O as listCommand$12, On as pagedLogArgs, P as generateMigrationScript, Pt as executionsCommand, Rt as formatKeyValueTable, Sn as defineAppCommand, St as triggerCommand, T as healthCommand, Tn as confirmationArgs, U as updateCommand$3, Vt as deploy, Y as getCommand$5, Yt as INITIAL_SCHEMA_NUMBER, Z as updateCommand$2, _n as generateUserTypes, at as createCommand$3, b as createCommand$4, c as listCommand$14, cn as reconstructSnapshotFromMigrations, f as restoreCommand, ft as tokenCommand, g as getCommand$7, gn as PluginManager, gt as listCommand$7, hn as sdkNameLabelKey, ht as generate, i as updateCommand$4, in as getMigrationFiles, j as truncateCommand, jn as workspaceArgs, kn as paginationArgs, ln as formatMigrationNumber, lt as getCommand$3, m as listCommand$15, mn as resourceTrn, o as removeCommand, on as isValidMigrationNumber, pn as getNamespacesWithMigrations, pt as listCommand$8, q as listCommand$11, r as queryCommand, rn as getMigrationFilePath, rt as deleteCommand$3, sn as loadDiff, st as listCommand$9, t as isNativeTypeScriptRuntime, tt as getCommand$4, u as inviteCommand, v as deleteCommand$4, vn as prompt, vt as getCommand$2, wn as configArg, wt as listCommand$6, xn as assertWritable, xt as webhookCommand, yn as apiCommand, z as showCommand, zt as getCommand$1 } from "../runtime-C0_FZWdE.mjs";
-import { C as getDistDir, D as deleteUserTokens, E as loadConfig, F as writePlatformConfig, M as readPlatformConfig, N as resolveTokens, O as fetchLatestToken, P as saveUserTokens, a as WorkflowJobSchema, b as createLogLevelTreeshakeOptions, i as resolveInlineSourcemap, j as loadWorkspaceId, k as loadAccessToken, l as ExecutorSchema, o as ResolverSchema, t as defineApplication, u as INVOKER_EXPR, v as platformBundleDefinePlugin, w as hashContent, x as resolveBundleLogLevel, y as composeFunctionTreeshakeOptions } from "../application-pusdxz35.mjs";
+import { $ as listCommand$10, $t as INITIAL_SCHEMA_NUMBER, An as configArg, At as startCommand, B as logBetaWarning, C as listCommand$13, Cn as generateUserTypes, Dn as assertWritable, Dt as jobsCommand, E as resumeCommand, F as writeDbTypesFile, Fn as paginationArgs, Gt as MIGRATION_LABEL_KEY, H as removeCommand$1, Ht as executeScript, I as getConfiguredEditorCommand, In as toPageDirection, Jt as compareSnapshotWithRemote, K as treeCommand, Kt as handleOptionalToRequiredError, L as openInConfiguredEditor, Ln as workspaceArgs, Lt as functionExecutionStatusToString, Mn as deploymentArgs, Mt as getCommand$6, N as generateCommand$1, Nn as isVerbose, O as listCommand$12, On as defineAppCommand, P as generateMigrationScript, Pn as pagedLogArgs, Pt as executionsCommand, Rt as formatKeyValueTable, Sn as PluginManager, St as triggerCommand, T as healthCommand, Tn as apiCommand, U as updateCommand$3, Vt as deploy, Xt as protoGqlPermission, Y as getCommand$5, Yt as generateAllTypeManifestsFromSnapshot, Z as updateCommand$2, _n as formatMigrationDiff, an as createSnapshotFromLocalTypes, at as createCommand$3, b as createCommand$4, bn as resourceTrn, c as listCommand$14, cn as getMigrationFilePath, dn as isValidMigrationNumber, f as restoreCommand, fn as loadDiff, ft as tokenCommand, g as getCommand$7, gt as listCommand$7, hn as parseMigrationNumberArg, ht as generate, i as updateCommand$4, j as truncateCommand, jn as confirmationArgs, kn as commonArgs, ln as getMigrationFiles, lt as getCommand$3, m as listCommand$15, mn as formatMigrationNumber, nn as assertValidMigrationFiles, o as removeCommand, on as getLatestMigrationNumber, pn as reconstructSnapshotFromMigrations, pt as listCommand$8, q as listCommand$11, qt as parseMigrationLabelNumber, r as queryCommand, rn as compareLocalTypesWithSnapshot, rt as deleteCommand$3, st as listCommand$9, t as isNativeTypeScriptRuntime, tt as getCommand$4, u as inviteCommand, v as deleteCommand$4, vn as hasChanges, vt as getCommand$2, wn as prompt, wt as listCommand$6, xn as sdkNameLabelKey, xt as webhookCommand, yn as getNamespacesWithMigrations, z as showCommand, zt as getCommand$1 } from "../runtime-C6o4hiYq.mjs";
+import { A as resolveTokens, C as loadConfig, E as loadAccessToken, M as writePlatformConfig, O as loadWorkspaceId, T as fetchLatestToken, _ as createLogLevelTreeshakeOptions, a as WorkflowJobSchema, b as getDistDir, c as INVOKER_EXPR, g as composeFunctionTreeshakeOptions, h as platformBundleDefinePlugin, i as resolveInlineSourcemap, j as saveUserTokens, k as readPlatformConfig, o as ResolverSchema, t as defineApplication, v as resolveBundleLogLevel, w as deleteUserTokens, x as hashContent } from "../application-BezXGbrU.mjs";
+import { n as ExecutorSchema } from "../service-wI3Hvrgx.mjs";
 import { t as multiline } from "../multiline-Cf9ODpr1.mjs";
-import { r as isPluginGeneratedType } from "../seed-C0fE2sJB.mjs";
+import { r as isPluginGeneratedType } from "../seed-BH2FbrPV.mjs";
 import { t as readPackageJson } from "../package-json-DcQApfPQ.mjs";
 import { n as isCLIError } from "../errors-EsY4XO6O.mjs";
-import { a as JSON_FOOTER_MARKER, i as CRASH_LOG_EXTENSION, o as parseCrashReportConfig, r as sendCrashReport, t as initCrashReporting } from "../crashreport-D3DvAzdg.mjs";
+import { a as JSON_FOOTER_MARKER, i as CRASH_LOG_EXTENSION, o as parseCrashReportConfig, r as sendCrashReport, t as initCrashReporting } from "../crashreport-BhD0y14F.mjs";
 import { arg, defineCommand, runCommand, runMain } from "politty";
 import { withCompletionCommand } from "politty/completion";
 import { z } from "zod";
@@ -74,10 +76,7 @@ const authorizeAuthConnectionCommand = defineAppCommand({
 	}).strict(),
 	run: async (args) => {
 		await assertWritable({ profile: args.profile });
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
+		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const workspaceId = await loadWorkspaceId({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
@@ -178,10 +177,7 @@ const deleteAuthConnectionCommand = defineAppCommand({
 	}).strict(),
 	run: async (args) => {
 		await assertWritable({ profile: args.profile });
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
+		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const workspaceId = await loadWorkspaceId({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
@@ -228,10 +224,7 @@ const listAuthConnectionCommand = defineAppCommand({
 		...paginationArgs()
 	}).strict(),
 	run: async (args) => {
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
+		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const workspaceId = await loadWorkspaceId({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
@@ -308,10 +301,7 @@ const revokeAuthConnectionCommand = defineAppCommand({
 	}).strict(),
 	run: async (args) => {
 		await assertWritable({ profile: args.profile });
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
+		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const workspaceId = await loadWorkspaceId({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
@@ -487,6 +477,7 @@ const deployCommand$1 = defineAppCommand({
 			description: "Run the command without making any changes"
 		}),
 		"no-schema-check": arg(z.boolean().optional(), { description: "Skip schema diff check against migration snapshots" }),
+		"no-validate": arg(z.boolean().optional(), { description: "Skip client-side validation against platform resource constraints" }),
 		"no-cache": arg(z.boolean().optional(), { description: "Disable bundle caching for this run" }),
 		"clean-cache": arg(z.boolean().optional(), { description: "Clean the bundle cache before building" })
 	}).strict(),
@@ -501,6 +492,7 @@ const deployCommand$1 = defineAppCommand({
 			dryRun: args["dry-run"],
 			yes: args.yes,
 			noSchemaCheck: args["no-schema-check"],
+			noValidate: args["no-validate"],
 			noCache: args["no-cache"],
 			cleanCache: args["clean-cache"]
 		});
@@ -644,9 +636,9 @@ function parseStackTrace(error) {
 		const match = STACK_FRAME_REGEX.exec(line);
 		if (match) frames.push({
 			functionName: match[1] || "<anonymous>",
-			file: match[2],
-			line: Number(match[3]),
-			column: Number(match[4])
+			file: assertDefined(match[2], "stack frame file missing"),
+			line: Number(assertDefined(match[3], "stack frame line missing")),
+			column: Number(assertDefined(match[4], "stack frame column missing"))
 		});
 	}
 	return {
@@ -664,7 +656,7 @@ function extractInlineSourcemap(bundledCode) {
 	const match = INLINE_SOURCEMAP_REGEX.exec(bundledCode);
 	if (!match) return null;
 	try {
-		const decoded = Buffer.from(match[1], "base64").toString("utf-8");
+		const decoded = Buffer.from(assertDefined(match[1], "sourcemap base64 data missing"), "base64").toString("utf-8");
 		return new TraceMap(JSON.parse(decoded));
 	} catch {
 		return null;
@@ -918,7 +910,7 @@ function composeExecutionErrorString(error) {
 */
 function formatExecutionErrorFallback(error) {
 	const [headerLine, ...frameLines] = composeExecutionErrorString(error).split("\n");
-	return [`  ${styles.error(headerLine ?? "")}`, ...frameLines.map((line) => `  ${styles.dim(line)}`)].join("\n");
+	return [`  ${styles.error(headerLine)}`, ...frameLines.map((line) => `  ${styles.dim(line)}`)].join("\n");
 }
 /**
 * Format an execution error for display, applying sourcemap mapping
@@ -1061,10 +1053,7 @@ Stack traces stay accurate even after later redeploys, because the trace is reso
 		})
 	}).strict(),
 	run: async (args) => {
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
+		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const workspaceId = await loadWorkspaceId({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
@@ -1228,7 +1217,7 @@ function generateEntry(detected, sourceFile, env, machineUser, workspaceId) {
       `;
 		}
 		case "workflow-job": {
-			const exportName = detected.exportName;
+			const exportName = assertDefined(detected.exportName, "workflow job export name missing");
 			return multiline`
         import { ${exportName} } from "${absoluteSourcePath}";
 
@@ -1294,7 +1283,7 @@ async function detectFunctionType(options) {
 		const rawInput = module.default.input;
 		let inputSchema;
 		if (rawInput) {
-			const { t } = await import("../types-Ccwchyj5.mjs");
+			const { t } = await import("../types-2Be3wSMc.mjs");
 			inputSchema = t.object(rawInput);
 		}
 		return {
@@ -1362,11 +1351,15 @@ function detectWorkflowJob(module, jobName) {
 			exportName: match.exportName
 		};
 	}
-	if (jobs.length === 1) return {
-		type: "workflow-job",
-		name: jobs[0].name,
-		exportName: jobs[0].exportName
-	};
+	if (jobs.length === 1) {
+		const [jobEntry] = jobs;
+		const job = assertDefined(jobEntry, "workflow job missing");
+		return {
+			type: "workflow-job",
+			name: job.name,
+			exportName: job.exportName
+		};
+	}
 	const available = jobs.map((j) => `  - "${j.name}" (export: ${j.exportName})`).join("\n");
 	throw new Error(`Multiple workflow jobs found. Specify one with --name:\n${available}`);
 }
@@ -1441,10 +1434,7 @@ When a \`.js\` file is provided, detection and bundling are skipped and the file
 		const { config } = await loadConfig(args.config);
 		const authNamespace = resolveAuthNamespace(config.auth);
 		const machineUserName = resolveMachineUserName(args["machine-user"], config.auth);
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
+		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const workspaceId = await loadWorkspaceId({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
@@ -1518,7 +1508,7 @@ When a \`.js\` file is provided, detection and bundling are skipped and the file
 		else {
 			if (result.success) logger.success("Execution succeeded");
 			else logger.error("Execution failed");
-			if (result.logs?.trim()) {
+			if (result.logs.trim()) {
 				logger.log(styles.bold("\nLogs:"));
 				for (const line of result.logs.split("\n")) logger.log(`  ${line}`);
 			}
@@ -1562,7 +1552,7 @@ function resolveMachineUserName(cliMachineUser, authConfig) {
 		const machineUsers = authConfig.machineUsers;
 		if (machineUsers) {
 			const keys = Object.keys(machineUsers);
-			if (keys.length > 0) return keys[0];
+			if (keys.length > 0) return assertDefined(keys[0], "machine user key missing");
 		}
 	}
 	throw new Error("Machine user is required. Provide --machine-user or ensure tailor.config.ts has machine users configured.");
@@ -1617,7 +1607,7 @@ function resolveResolverArg(argStr, inputSchema, machineUser, workspaceId) {
 		type: "machine_user",
 		workspaceId,
 		attributes: machineUser.attributes ?? null,
-		attributeList: machineUser.attributeList ?? []
+		attributeList: machineUser.attributeList
 	};
 	if (!inputSchema.parse({
 		value: parsed,
@@ -1751,7 +1741,7 @@ const startAuthServer = async () => {
 				await saveUserTokens(pfConfig, userInfo.email, {
 					accessToken: tokens.accessToken,
 					refreshToken: tokens.refreshToken ?? void 0
-				}, new Date(tokens.expiresAt).toISOString());
+				}, new Date(assertDefined(tokens.expiresAt, "token response missing expiresAt")).toISOString());
 				pfConfig.current_user = userInfo.email;
 				writePlatformConfig(pfConfig);
 				res.writeHead(200, { "Content-Type": "application/json" });
@@ -1797,7 +1787,7 @@ async function loginAsMachineUser(args) {
 	const clientSecret = args.clientSecret ?? await prompt.password({ message: "Client secret" });
 	const tokens = await fetchPlatformMachineUserToken(args.clientId, clientSecret);
 	const pfConfig = await readPlatformConfig();
-	await saveUserTokens(pfConfig, args.clientId, { accessToken: tokens.accessToken }, new Date(tokens.expiresAt).toISOString());
+	await saveUserTokens(pfConfig, args.clientId, { accessToken: tokens.accessToken }, new Date(assertDefined(tokens.expiresAt, "token response missing expiresAt")).toISOString());
 	pfConfig.current_user = args.clientId;
 	writePlatformConfig(pfConfig);
 }
@@ -1821,7 +1811,7 @@ const loginCommand = defineAppCommand({
 		})
 	}).strict().describe("Machine User Login")]),
 	run: async (args) => {
-		if ("machine-user" in args && args["machine-user"]) await loginAsMachineUser({
+		if ("machine-user" in args) await loginAsMachineUser({
 			clientId: args.clientId,
 			clientSecret: args.clientSecret
 		});
@@ -1839,13 +1829,14 @@ const logoutCommand = defineAppCommand({
 	args: z.object({}).strict(),
 	run: async () => {
 		const pfConfig = await readPlatformConfig();
-		const userEntry = pfConfig.current_user ? pfConfig.users[pfConfig.current_user] : void 0;
-		if (!userEntry) {
+		const currentUser = pfConfig.current_user;
+		const userEntry = currentUser ? pfConfig.users[currentUser] : void 0;
+		if (!userEntry || !currentUser) {
 			logger.info("You are not logged in.");
 			return;
 		}
 		try {
-			const { accessToken, refreshToken } = await resolveTokens(userEntry, pfConfig.current_user);
+			const { accessToken, refreshToken } = await resolveTokens(userEntry, currentUser);
 			const client = initOAuth2Client();
 			const tokenTypeHint = refreshToken ? "refresh_token" : "access_token";
 			await client.revoke({
@@ -1856,8 +1847,8 @@ const logoutCommand = defineAppCommand({
 		} catch (error) {
 			logger.warn(`Failed to revoke token: ${error instanceof Error ? error.message : error}`);
 		}
-		await deleteUserTokens(pfConfig, pfConfig.current_user);
-		delete pfConfig.users[pfConfig.current_user];
+		await deleteUserTokens(pfConfig, currentUser);
+		delete pfConfig.users[currentUser];
 		pfConfig.current_user = null;
 		writePlatformConfig(pfConfig);
 		logger.success("Successfully logged out from Tailor Platform.");
@@ -2048,12 +2039,15 @@ const listCommand$4 = defineAppCommand({
 			if (jsonOutput) logger.out([]);
 			return;
 		}
-		const profileInfos = profiles.map(([name, profile]) => ({
-			name,
-			user: profile.user,
-			workspaceId: profile.workspace_id,
-			permission: profile.readonly === true ? "read" : "write"
-		}));
+		const profileInfos = profiles.map(([name, profile]) => {
+			const p = assertDefined(profile, `profile entry "${name}" is undefined`);
+			return {
+				name,
+				user: p.user,
+				workspaceId: p.workspace_id,
+				permission: p.readonly === true ? "read" : "write"
+			};
+		});
 		logger.out(profileInfos);
 	}
 });
@@ -2080,9 +2074,9 @@ const updateCommand$1 = defineAppCommand({
 	}).strict(),
 	run: async (args) => {
 		const config = await readPlatformConfig();
-		if (!config.profiles[args.name]) throw new Error(`Profile "${args.name}" not found.`);
-		if (!args.user && !args["workspace-id"] && args.permission === void 0) throw new Error("Please provide at least one property to update.");
 		const profile = config.profiles[args.name];
+		if (!profile) throw new Error(`Profile "${args.name}" not found.`);
+		if (!args.user && !args["workspace-id"] && args.permission === void 0) throw new Error("Please provide at least one property to update.");
 		const oldUser = profile.user;
 		const newUser = args.user || oldUser;
 		const oldWorkspaceId = profile.workspace_id;
@@ -2222,10 +2216,7 @@ const createSecretCommand = defineAppCommand({
 	}).strict(),
 	run: async (args) => {
 		await assertWritable({ profile: args.profile });
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
+		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const workspaceId = await loadWorkspaceId({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
@@ -2275,10 +2266,7 @@ const deleteSecretCommand = defineAppCommand({
 	}).strict(),
 	run: async (args) => {
 		await assertWritable({ profile: args.profile });
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
+		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const workspaceId = await loadWorkspaceId({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
@@ -2327,10 +2315,7 @@ function secretInfo(secret) {
 * @returns List of secrets
 */
 async function secretList(options) {
-	const client = await initOperatorClient(await loadAccessToken({
-		useProfile: true,
-		profile: options.profile
-	}));
+	const client = await initOperatorClient(await loadAccessToken({ profile: options.profile }));
 	const workspaceId = await loadWorkspaceId({
 		workspaceId: options.workspaceId,
 		profile: options.profile
@@ -2384,10 +2369,7 @@ const updateSecretCommand = defineAppCommand({
 	}).strict(),
 	run: async (args) => {
 		await assertWritable({ profile: args.profile });
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
+		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const workspaceId = await loadWorkspaceId({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
@@ -2440,10 +2422,7 @@ const createCommand$1 = defineAppCommand({
 	}).strict(),
 	run: async (args) => {
 		await assertWritable({ profile: args.profile });
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
+		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const workspaceId = await loadWorkspaceId({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
@@ -2473,10 +2452,7 @@ const deleteCommand$1 = defineAppCommand({
 	}).strict(),
 	run: async (args) => {
 		await assertWritable({ profile: args.profile });
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
+		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const workspaceId = await loadWorkspaceId({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
@@ -2521,10 +2497,7 @@ function vaultInfo(vault) {
 * @returns List of vaults
 */
 async function vaultList(options) {
-	const client = await initOperatorClient(await loadAccessToken({
-		useProfile: true,
-		profile: options?.profile
-	}));
+	const client = await initOperatorClient(await loadAccessToken({ profile: options?.profile }));
 	const workspaceId = await loadWorkspaceId({
 		workspaceId: options?.workspaceId,
 		profile: options?.profile
@@ -3044,10 +3017,7 @@ const deployCommand = defineAppCommand({
 	run: async (args) => {
 		await assertWritable({ profile: args.profile });
 		logger.info(`Deploying static website "${args.name}" from directory: ${args.dir}`);
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
+		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const name = args.name;
 		const dir = path.resolve(process.cwd(), args.dir);
 		const workspaceId = await loadWorkspaceId({
@@ -3093,10 +3063,7 @@ const domainGetCommand = defineAppCommand({
 		})
 	}).strict(),
 	run: async (args) => {
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
+		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const workspaceId = await loadWorkspaceId({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
@@ -3136,10 +3103,7 @@ const domainListCommand = defineAppCommand({
 		})
 	}).strict(),
 	run: async (args) => {
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
+		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const workspaceId = await loadWorkspaceId({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
@@ -3191,10 +3155,7 @@ const getCommand = defineAppCommand({
 		})
 	}).strict(),
 	run: async (args) => {
-		const client = await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		}));
+		const client = await initOperatorClient(await loadAccessToken({ profile: args.profile }));
 		const workspaceId = await loadWorkspaceId({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
@@ -3229,10 +3190,7 @@ const getCommand = defineAppCommand({
 * @returns List of static websites
 */
 async function listStaticWebsites(options) {
-	const client = await initOperatorClient(await loadAccessToken({
-		useProfile: true,
-		profile: options?.profile
-	}));
+	const client = await initOperatorClient(await loadAccessToken({ profile: options?.profile }));
 	const workspaceId = await loadWorkspaceId({
 		workspaceId: options?.workspaceId,
 		profile: options?.profile
@@ -3250,7 +3208,7 @@ async function listStaticWebsites(options) {
 		workspaceId,
 		name: site.name,
 		description: site.description,
-		url: site.url ?? "",
+		url: site.url,
 		allowedIpAddresses: site.allowedIpAddresses
 	}));
 }
@@ -3551,10 +3509,7 @@ function initErdCommand() {
 async function initErdDeployContext(args) {
 	initErdCommand();
 	return {
-		client: await initOperatorClient(await loadAccessToken({
-			useProfile: true,
-			profile: args.profile
-		})),
+		client: await initOperatorClient(await loadAccessToken({ profile: args.profile })),
 		workspaceId: await loadWorkspaceId({
 			workspaceId: args.workspaceId,
 			profile: args.profile
@@ -4153,18 +4108,13 @@ const erdCommand = defineCommand({
 */
 async function script(options) {
 	logBetaWarning("tailordb migration");
-	let migrationNumber;
-	if (isValidMigrationNumber(options.number)) migrationNumber = parseInt(options.number, 10);
-	else if (/^[1-9]\d*$/.test(options.number)) {
-		migrationNumber = parseInt(options.number, 10);
-		if (migrationNumber > 9999) throw new Error(`Migration number ${options.number} is out of range. Expected 1-9999.`);
-	} else throw new Error(`Invalid migration number format: ${options.number}. Expected 4-digit format (e.g., 0001) or integer 1-9999 (e.g., 1).`);
+	const migrationNumber = parseMigrationNumberArg(options.number);
 	if (migrationNumber === 0) throw new Error(`Migration ${options.number} is the initial schema snapshot and cannot have a migration script.`);
 	const { config } = await loadConfig(options.configPath);
 	const namespacesWithMigrations = getNamespacesWithMigrations(config, path.dirname(config.path));
 	if (namespacesWithMigrations.length === 0) throw new Error("No TailorDB services with migrations configuration found");
 	const targetNamespace = resolveTargetNamespace(namespacesWithMigrations, options.namespace);
-	const { migrationsDir } = namespacesWithMigrations.find((ns) => ns.namespace === targetNamespace);
+	const { migrationsDir } = assertDefined(namespacesWithMigrations.find((ns) => ns.namespace === targetNamespace), "namespace with migrations not found");
 	const diffPath = getMigrationFilePath(migrationsDir, migrationNumber, "diff");
 	if (!fs$1.existsSync(diffPath)) throw new Error(`Migration ${options.number} not found in ${migrationsDir}. Expected ${diffPath}.`);
 	const migratePath = getMigrationFilePath(migrationsDir, migrationNumber, "migrate");
@@ -4196,7 +4146,10 @@ function resolveTargetNamespace(namespacesWithMigrations, requested) {
 		if (!namespacesWithMigrations.some((ns) => ns.namespace === requested)) throw new Error(`Namespace "${requested}" not found or does not have migrations configured`);
 		return requested;
 	}
-	if (namespacesWithMigrations.length === 1) return namespacesWithMigrations[0].namespace;
+	if (namespacesWithMigrations.length === 1) {
+		const [ns] = namespacesWithMigrations;
+		return assertDefined(ns, "namespace with migrations missing").namespace;
+	}
 	throw new Error(`Multiple TailorDB services found. Please specify namespace with --namespace flag: ${namespacesWithMigrations.map((ns) => ns.namespace).join(", ")}`);
 }
 const scriptCommand = defineAppCommand({
@@ -4244,12 +4197,11 @@ async function set(options) {
 	if (options.namespace) {
 		if (!namespacesWithMigrations.some((ns) => ns.namespace === options.namespace)) throw new Error(`Namespace "${options.namespace}" not found or does not have migrations configured`);
 		targetNamespace = options.namespace;
-	} else if (namespacesWithMigrations.length === 1) targetNamespace = namespacesWithMigrations[0].namespace;
-	else throw new Error(`Multiple TailorDB services found. Please specify namespace with --namespace flag: ${namespacesWithMigrations.map((ns) => ns.namespace).join(", ")}`);
-	const client = await initOperatorClient(await loadAccessToken({
-		useProfile: false,
-		profile: options.profile
-	}));
+	} else if (namespacesWithMigrations.length === 1) {
+		const [ns] = namespacesWithMigrations;
+		targetNamespace = assertDefined(ns, "namespace with migrations missing").namespace;
+	} else throw new Error(`Multiple TailorDB services found. Please specify namespace with --namespace flag: ${namespacesWithMigrations.map((ns) => ns.namespace).join(", ")}`);
+	const client = await initOperatorClient(await loadAccessToken({ profile: options.profile }));
 	const trn = resourceTrn(await loadWorkspaceId({
 		workspaceId: options.workspaceId,
 		profile: options.profile
@@ -4257,7 +4209,7 @@ async function set(options) {
 	let currentMigration;
 	try {
 		const { metadata } = await client.getMetadata({ trn });
-		const label = metadata?.labels?.["sdk-migration"];
+		const label = metadata?.labels["sdk-migration"];
 		currentMigration = label ? parseMigrationLabelNumber(label) ?? 0 : 0;
 	} catch {
 		currentMigration = 0;
@@ -4332,10 +4284,7 @@ async function collectMigrationStatuses(options) {
 	if (namespacesWithMigrations.length === 0) throw new Error("No TailorDB services with migrations configuration found");
 	const targetNamespaces = options.namespace ? namespacesWithMigrations.filter((ns) => ns.namespace === options.namespace) : namespacesWithMigrations;
 	if (targetNamespaces.length === 0) throw new Error(`Namespace "${options.namespace}" not found or does not have migrations configured`);
-	const client = await initOperatorClient(await loadAccessToken({
-		useProfile: false,
-		profile: options.profile
-	}));
+	const client = await initOperatorClient(await loadAccessToken({ profile: options.profile }));
 	const workspaceId = await loadWorkspaceId({
 		workspaceId: options.workspaceId,
 		profile: options.profile
@@ -4346,7 +4295,7 @@ async function collectMigrationStatuses(options) {
 		let currentMigration;
 		try {
 			const { metadata } = await client.getMetadata({ trn });
-			const label = metadata?.labels?.["sdk-migration"];
+			const label = metadata?.labels["sdk-migration"];
 			currentMigration = label ? parseMigrationLabelNumber(label) ?? 0 : 0;
 		} catch {
 			currentMigration = 0;
@@ -4419,6 +4368,295 @@ const statusCommand = defineAppCommand({
 	}
 });
 
+//#endregion
+//#region src/cli/commands/tailordb/migrate/sync.ts
+async function fetchRemoteGqlPermissions(client, workspaceId, namespace) {
+	return fetchAll(async (pageToken, maxPageSize) => {
+		try {
+			const { permissions, nextPageToken } = await client.listTailorDBGQLPermissions({
+				workspaceId,
+				namespaceName: namespace,
+				pageToken,
+				pageSize: maxPageSize
+			});
+			return [permissions, nextPageToken];
+		} catch (error) {
+			if (error instanceof ConnectError && error.code === Code.NotFound) return [[], ""];
+			throw error;
+		}
+	});
+}
+async function fetchRemoteTypes(client, workspaceId, namespace) {
+	return fetchAll(async (pageToken, maxPageSize) => {
+		try {
+			const { tailordbTypes, nextPageToken } = await client.listTailorDBTypes({
+				workspaceId,
+				namespaceName: namespace,
+				pageToken,
+				pageSize: maxPageSize
+			});
+			return [tailordbTypes, nextPageToken];
+		} catch (error) {
+			if (error instanceof ConnectError && error.code === Code.NotFound) throw new Error(`Cannot sync: TailorDB namespace "${namespace}" has not been deployed yet.`, { cause: error });
+			throw error;
+		}
+	});
+}
+/**
+* Verify that replaying the full migration history reproduces the current
+* local type definitions, before anything is sent to the remote.
+*
+* Sync force-applies a snapshot reconstructed from the migration history, so
+* the history itself must be trustworthy. When the reconstruction at the
+* latest migration does not match the schema defined in the local type files,
+* either the migration files were edited incorrectly or a schema change has
+* not been recorded as a migration yet — and overwriting the remote with an
+* unverified snapshot could destroy data. Fails before any RPC is issued.
+*
+* Returns the manifest generation options deploy would use for this
+* namespace (executor-driven publishRecordEvents and namespace
+* gqlOperations), so the synced manifests match what deploy produces.
+* @param loaded - Result of `loadConfig` (config and plugins)
+* @param target - Namespace whose migration history is being synced
+* @returns Options for `generateAllTypeManifestsFromSnapshot`
+*/
+async function assertMigrationsReproduceLocalTypes(loaded, target) {
+	const { config, plugins } = loaded;
+	const pluginManager = plugins.length > 0 ? new PluginManager(plugins) : void 0;
+	const { defineApplication, generatePluginFilesIfNeeded } = await import("../application-DSXntqnV.mjs");
+	const application = defineApplication({
+		config,
+		pluginManager
+	});
+	const tailordbService = application.tailorDBServices.find((s) => s.namespace === target.namespace);
+	if (!tailordbService) throw new Error(`No TailorDB service found for namespace "${target.namespace}"`);
+	for (const service of application.tailorDBServices) {
+		await service.loadTypes();
+		await service.processNamespacePlugins();
+	}
+	const pluginExecutorFiles = generatePluginFilesIfNeeded(pluginManager, application.tailorDBServices, config.path);
+	const executorService = application.executorService ?? (pluginExecutorFiles.length > 0 ? (await import("../service-BHQIerYh.mjs")).createExecutorService({ config: { files: [] } }) : void 0);
+	await executorService?.loadExecutors();
+	if (pluginExecutorFiles.length > 0) await executorService?.loadPluginExecutorFiles([...pluginExecutorFiles]);
+	const executorUsedTypes = /* @__PURE__ */ new Set();
+	for (const executor of Object.values(executorService?.executors ?? {})) if (executor.trigger.kind === "tailordb") executorUsedTypes.add(executor.trigger.typeName);
+	const manifestOptions = {
+		executorUsedTypes,
+		namespaceGqlOperations: tailordbService.config.gqlOperations
+	};
+	const latestSnapshot = reconstructSnapshotFromMigrations(target.migrationsDir);
+	if (!latestSnapshot) return manifestOptions;
+	const diff = compareLocalTypesWithSnapshot(latestSnapshot, createSnapshotFromLocalTypes(tailordbService.types, target.namespace).types, target.namespace);
+	if (!hasChanges(diff)) return manifestOptions;
+	logger.error(`Migration history does not reproduce the current local schema for namespace ${styles.bold(target.namespace)}:`);
+	logger.log(formatMigrationDiff(diff));
+	logger.newline();
+	logger.info("This usually means one of the following:");
+	logger.info("  - Migration files were edited and replaying them no longer matches the type definitions — fix the migration files.", { mode: "plain" });
+	logger.info("  - Type definitions changed without a new migration — run 'tailor-sdk tailordb migration generate' first.", { mode: "plain" });
+	logger.newline();
+	throw new Error("Refusing to sync: the migration history must reproduce the current local schema before it can be applied to the remote.");
+}
+/**
+* Fetch the namespace's metadata labels and current migration number.
+*
+* Only GetMetadata NotFound is treated as "metadata does not exist yet".
+* Any other failure aborts the sync (which has not mutated anything at this
+* point): the fetched labels are written back verbatim at the end, so
+* proceeding with empty labels after a transient error would wipe the
+* namespace's existing metadata.
+* @param client - Operator client
+* @param trn - Namespace TRN
+* @returns Existing labels and the parsed current migration number
+*/
+async function fetchRemoteMigrationState(client, trn) {
+	try {
+		const { metadata } = await client.getMetadata({ trn });
+		const labels = metadata?.labels ?? {};
+		const label = labels[MIGRATION_LABEL_KEY];
+		return {
+			labels,
+			current: label ? parseMigrationLabelNumber(label) : null
+		};
+	} catch (error) {
+		if (error instanceof ConnectError && error.code === Code.NotFound) return {
+			labels: {},
+			current: null
+		};
+		throw error;
+	}
+}
+function selectTargetNamespace(namespacesWithMigrations, requested) {
+	if (namespacesWithMigrations.length === 0) throw new Error("No TailorDB services with migrations configuration found");
+	if (requested) {
+		const found = namespacesWithMigrations.find((ns) => ns.namespace === requested);
+		if (!found) throw new Error(`Namespace "${requested}" not found or does not have migrations configured`);
+		return found;
+	}
+	if (namespacesWithMigrations.length > 1) throw new Error(`Multiple TailorDB services found. Please specify namespace with --namespace flag: ${namespacesWithMigrations.map((ns) => ns.namespace).join(", ")}`);
+	return assertDefined(namespacesWithMigrations[0], "namespace with migrations missing");
+}
+/**
+* Sync remote TailorDB schema to a specific migration snapshot.
+*
+* Reconstructs the schema state at `<number>` from `0000/schema.json` + diffs,
+* then issues create/update/delete RPCs so the remote matches that snapshot.
+* Updates the migration label to `<number>` on success. Before any remote
+* mutation, verifies that the migration history reproduces the current local
+* type definitions (see {@link assertMigrationsReproduceLocalTypes}).
+*
+* Intended for recovering from drift introduced by `deploy --no-schema-check`
+* runs against an older revision: instead of having to `git checkout` that
+* revision and re-deploy, the operator can sync the remote back to a known
+* snapshot version directly.
+* @param options - Command options
+*/
+async function sync(options) {
+	logBetaWarning("tailordb migration");
+	const targetVersion = parseMigrationNumberArg(options.number);
+	const loaded = await loadConfig(options.configPath);
+	const { config } = loaded;
+	const target = selectTargetNamespace(getNamespacesWithMigrations(config, path.dirname(config.path)), options.namespace);
+	assertValidMigrationFiles(target.migrationsDir, target.namespace);
+	const latest = getLatestMigrationNumber(target.migrationsDir);
+	if (targetVersion > latest) throw new Error(`Migration ${formatMigrationNumber(targetVersion)} does not exist in working tree (latest is ${formatMigrationNumber(latest)}).`);
+	const snapshot = reconstructSnapshotFromMigrations(target.migrationsDir, targetVersion);
+	if (!snapshot) throw new Error(`No initial schema snapshot found in ${target.migrationsDir}. Expected 0000/schema.json.`);
+	const manifestOptions = await assertMigrationsReproduceLocalTypes(loaded, target);
+	const client = await initOperatorClient(await loadAccessToken({ profile: options.profile }));
+	const workspaceId = await loadWorkspaceId({
+		workspaceId: options.workspaceId,
+		profile: options.profile
+	});
+	const trn = resourceTrn(workspaceId, "tailordb", target.namespace);
+	const remoteState = await fetchRemoteMigrationState(client, trn);
+	const remoteTypes = await fetchRemoteTypes(client, workspaceId, target.namespace);
+	const { creates, updates, deletes } = compareSnapshotWithRemote(snapshot, new Set(remoteTypes.map((t) => t.name)));
+	const remoteGqlPermissions = await fetchRemoteGqlPermissions(client, workspaceId, target.namespace);
+	const remoteGqlPermissionTypes = new Set(remoteGqlPermissions.map((p) => p.typeName));
+	const desiredGqlPermissions = Object.entries(snapshot.types).flatMap(([typeName, snapshotType]) => snapshotType.permissions?.gql ? [{
+		typeName,
+		permission: protoGqlPermission(snapshotType.permissions.gql)
+	}] : []);
+	const desiredGqlPermissionTypes = new Set(desiredGqlPermissions.map((p) => p.typeName));
+	const gqlPermissionDeletes = remoteGqlPermissions.filter((p) => !desiredGqlPermissionTypes.has(p.typeName));
+	const current = remoteState.current;
+	logger.newline();
+	logger.info(`Namespace: ${styles.bold(target.namespace)}`);
+	logger.log(`  Current migration: ${current === null ? "<unset>" : styles.bold(formatMigrationNumber(current))}`);
+	logger.log(`  Target migration: ${styles.bold(formatMigrationNumber(targetVersion))}`);
+	logger.log(`  Types to create: ${styles.bold(String(creates.length))}`);
+	logger.log(`  Types to update: ${styles.bold(String(updates.length))}`);
+	logger.log(`  Types to delete: ${styles.bold(String(deletes.length))}`);
+	logger.log(`  GQL permissions to set: ${styles.bold(String(desiredGqlPermissions.length))}`);
+	logger.log(`  GQL permissions to delete: ${styles.bold(String(gqlPermissionDeletes.length))}`);
+	logger.newline();
+	if (creates.length + updates.length + deletes.length + desiredGqlPermissions.length + gqlPermissionDeletes.length === 0) logger.info("No types to apply; only the migration label will be updated.");
+	else {
+		logger.warn("This operation will overwrite remote TailorDB types to match the selected snapshot.");
+		if (deletes.length > 0) logger.warn("Existing data in deleted types will be lost.");
+		logger.newline();
+	}
+	logger.warn("Sync never runs migrate.ts scripts; it only applies the schema snapshot and moves the migration label.");
+	logger.newline();
+	if (current !== null && targetVersion < current) {
+		logger.warn(`Migrations ${formatMigrationNumber(targetVersion + 1)}–${formatMigrationNumber(current)} will become pending again and re-execute on the next deploy, including their migrate.ts scripts. Make sure those scripts are idempotent (safe to re-run).`);
+		logger.newline();
+	} else if (current !== null && targetVersion > current) {
+		logger.warn(`Moving the migration label forwards (${formatMigrationNumber(current)} → ${formatMigrationNumber(targetVersion)}): migrate.ts scripts for migrations ${formatMigrationNumber(current + 1)}–${formatMigrationNumber(targetVersion)} will not run on the next deploy.`);
+		logger.newline();
+	}
+	if (!options.yes) {
+		if (!await prompt.confirm({
+			message: `Continue and set migration label to ${formatMigrationNumber(targetVersion)}?`,
+			default: false
+		})) {
+			logger.info("Operation cancelled.");
+			return;
+		}
+		logger.newline();
+	}
+	const manifests = generateAllTypeManifestsFromSnapshot(snapshot, manifestOptions);
+	const manifestFor = (typeName) => {
+		const manifest = manifests.get(typeName);
+		if (!manifest) throw new Error(`Internal error: no manifest generated for type "${typeName}". No changes were applied.`);
+		return manifest;
+	};
+	const createManifests = creates.map((typeName) => manifestFor(typeName));
+	const updateManifests = updates.map((typeName) => manifestFor(typeName));
+	try {
+		await Promise.all([...createManifests.map((tailordbType) => client.createTailorDBType({
+			workspaceId,
+			namespaceName: target.namespace,
+			tailordbType
+		})), ...updateManifests.map((tailordbType) => client.updateTailorDBType({
+			workspaceId,
+			namespaceName: target.namespace,
+			tailordbType
+		}))]);
+	} catch (error) {
+		handleOptionalToRequiredError(error, ["The target snapshot marks a field as required, but existing remote records have no value for it.", "Populate those records first (e.g. with a migration script applied via 'tailor-sdk deploy'), then re-run the sync."]);
+	}
+	await Promise.all(desiredGqlPermissions.map(({ typeName, permission }) => {
+		const request = {
+			workspaceId,
+			namespaceName: target.namespace,
+			typeName,
+			permission
+		};
+		return remoteGqlPermissionTypes.has(typeName) ? client.updateTailorDBGQLPermission(request) : client.createTailorDBGQLPermission(request);
+	}));
+	await Promise.all(gqlPermissionDeletes.map((p) => client.deleteTailorDBGQLPermission({
+		workspaceId,
+		namespaceName: target.namespace,
+		typeName: p.typeName
+	})));
+	await Promise.all(deletes.map((typeName) => client.deleteTailorDBType({
+		workspaceId,
+		namespaceName: target.namespace,
+		tailordbTypeName: typeName
+	})));
+	await client.setMetadata({
+		trn,
+		labels: {
+			...remoteState.labels,
+			[MIGRATION_LABEL_KEY]: `${"m"}${formatMigrationNumber(targetVersion)}`
+		}
+	});
+	logger.success(`Synced namespace ${styles.bold(target.namespace)} to migration ${styles.bold(formatMigrationNumber(targetVersion))}.`);
+	if (targetVersion < latest) {
+		logger.newline();
+		logger.info(`Run 'tailor-sdk deploy' to apply migrations ${formatMigrationNumber(targetVersion + 1)}–${formatMigrationNumber(latest)} from the working tree.`);
+	}
+}
+const syncCommand = defineAppCommand({
+	name: "sync",
+	description: "Sync remote TailorDB schema to a specific migration snapshot (recovery from --no-schema-check drift).",
+	args: z.object({
+		...deploymentArgs,
+		...confirmationArgs,
+		number: arg(z.string(), {
+			positional: true,
+			description: "Migration number to sync to (e.g., 0001 or 1; 0 targets the baseline snapshot)"
+		}),
+		namespace: arg(z.string().optional(), {
+			alias: "n",
+			description: "Target TailorDB namespace (required if multiple namespaces exist)"
+		})
+	}).strict(),
+	run: async (args) => {
+		await assertWritable({ profile: args.profile });
+		await sync({
+			configPath: args.config,
+			number: args.number,
+			namespace: args.namespace,
+			yes: args.yes,
+			workspaceId: args["workspace-id"],
+			profile: args.profile
+		});
+	}
+});
+
 //#endregion
 //#region src/cli/commands/tailordb/migrate/index.ts
 /**
@@ -4429,6 +4667,7 @@ const statusCommand = defineAppCommand({
 * - script:   Add a migrate.ts template to an existing migration
 * - set:      Set migration checkpoint to a specific number
 * - status:   Show migration status for TailorDB namespaces
+* - sync:     Sync remote TailorDB schema to a specific migration snapshot
 */
 const migrationCommand = defineCommand({
 	name: "migration",
@@ -4437,7 +4676,8 @@ const migrationCommand = defineCommand({
 		generate: generateCommand$1,
 		script: scriptCommand,
 		set: setCommand,
-		status: statusCommand
+		status: statusCommand,
+		sync: syncCommand
 	}
 });
 
@@ -4472,7 +4712,7 @@ const upgradeCommand = defineAppCommand({
 	run: async (args) => {
 		const { initTelemetry } = await import("../telemetry-w92bvGdC.mjs");
 		await initTelemetry();
-		const { upgrade } = await import("../service-aPT0fx3y.mjs");
+		const { upgrade } = await import("../service-DMohAx8a2.mjs");
 		await upgrade({
 			from: args.from,
 			dryRun: args["dry-run"],
@@ -4898,7 +5138,7 @@ runMain(mainCommand, {
 				if (isVerbose() && error.stack) logger.debug(`\nStack trace:\n${error.stack}`);
 			} else logger.error(`Unknown error: ${error}`);
 			if (!isCLIError(error) && (!(error instanceof Error) || error instanceof TypeError || error instanceof RangeError)) {
-				const { reportCrash } = await import("../crashreport-lnVTnbB5.mjs");
+				const { reportCrash } = await import("../crashreport-D1wKBJ8N.mjs");
 				await reportCrash(error, "handledError");
 			}
 		}