@tailor-platform/sdk 1.17.1 → 1.18.0

package/dist/{application-BMDE8KqK.mjs → application-gWUyKuzv.mjs}

@@ -1,5 +1,10 @@
-import { a as __toCommonJS, i as __require, n as __esmMin, o as __toESM, r as __exportAll, t as __commonJSMin } from "./chunk-GMkBE123.mjs";
-import { t as isPluginGeneratedType } from "./types-b-ig8nW_.mjs";
+import { a as __toCommonJS, i as __require, n as __esmMin, o as __toESM, r as __exportAll, t as __commonJSMin } from "./chunk-CqAI0b6X.mjs";
+import { t as isPluginGeneratedType } from "./types-ClK_HJ0G.mjs";
+import { n as isSdkBranded } from "./brand-BZJCv6UY.mjs";
+import { n as enumConstantsPlugin, t as EnumConstantsGeneratorID } from "./enum-constants-Cwd4qdpa.mjs";
+import { n as fileUtilsPlugin, t as FileUtilsGeneratorID } from "./file-utils-cqcpFk87.mjs";
+import { n as kyselyTypePlugin, t as KyselyGeneratorID } from "./kysely-type-DtUUoAi3.mjs";
+import { n as seedPlugin, t as SeedGeneratorID } from "./seed-Dm7lrGZ3.mjs";
 import Module, { createRequire } from "node:module";
 import { z } from "zod";
 import * as fs$15 from "node:fs";
@@ -1065,6 +1070,7 @@ function formatRequestParams(message) {
 		return "(unable to serialize request)";
 	}
 }
+const MAX_PAGE_SIZE = 1e3;
 /**
 * Fetch all paginated resources by repeatedly calling the given function.
 * @template T
@@ -1075,7 +1081,7 @@ async function fetchAll(fn) {
 	const items = [];
 	let pageToken = "";
 	while (true) {
-		const [batch, nextPageToken] = await fn(pageToken);
+		const [batch, nextPageToken] = await fn(pageToken, MAX_PAGE_SIZE);
 		items.push(...batch);
 		if (!nextPageToken) break;
 		pageToken = nextPageToken;
@@ -87395,7 +87401,7 @@ var require_config_loader = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 		* @returns {Promise<{createJiti: Function|undefined, version: string;}>} A promise that fulfills with an object containing the jiti module's createJiti function and version.
 		*/
 		static async loadJiti() {
-			const { createJiti } = await import("./jiti-BrELlEYT.mjs");
+			const { createJiti } = await import("./jiti-DHlauMCo.mjs");
 			return {
 				createJiti,
 				version: require_package$1().version
@@ -87737,7 +87743,7 @@ var require_eslint_helpers = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 	*/
 	async function globMatch({ basePath, pattern }) {
 		let found = false;
-		const { hfs } = await import("./src-DMROgdcL.mjs");
+		const { hfs } = await import("./src-i4uqS1G4.mjs");
 		const matcher = new Minimatch(normalizeToPosix(path$9.relative(basePath, pattern)), MINIMATCH_OPTIONS);
 		const walkSettings = {
 			directoryFilter(entry) {
@@ -87784,7 +87790,7 @@ var require_eslint_helpers = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 			return new Minimatch(patternToUse, MINIMATCH_OPTIONS);
 		});
 		const unmatchedPatterns = new Set([...relativeToPatterns.keys()]);
-		const { hfs } = await import("./src-DMROgdcL.mjs");
+		const { hfs } = await import("./src-i4uqS1G4.mjs");
 		const walk = hfs.walk(basePath, {
 			async directoryFilter(entry) {
 				if (!matchers.some((matcher) => matcher.match(entry.path, true))) return false;
@@ -98970,8 +98976,7 @@ function createTailorDBService(params) {
 				const exportedValue = module$1[exportName];
 				const result = TailorDBTypeSchema.safeParse(exportedValue);
 				if (!result.success) {
-					const gqlPermissionIssue = result.error.issues.find((i$1) => i$1.message.includes(GQL_PERMISSION_INVALID_OPERAND_MESSAGE));
-					if (gqlPermissionIssue) throw new Error(gqlPermissionIssue.message);
+					if (isSdkBranded(exportedValue)) throw result.error;
 					continue;
 				}
 				const relativePath = path$20.relative(process.cwd(), typeFile);
@@ -99447,6 +99452,7 @@ function createExecutorService(params) {
 				executors[executorFile] = result.data;
 				return result.data;
 			}
+			if (isSdkBranded(executorModule.default)) throw result.error;
 		} catch (error) {
 			const relativePath = path$20.relative(process.cwd(), executorFile);
 			logger.error(`Failed to load executor from ${styles.bold(relativePath)}`);
@@ -99507,6 +99513,7 @@ function createResolverService(namespace, config) {
 				resolvers[resolverFile] = result.data;
 				return result.data;
 			}
+			if (isSdkBranded(resolverModule.default)) throw result.error;
 		} catch (error) {
 			const relativePath = path$20.relative(process.cwd(), resolverFile);
 			logger.error(`Failed to load resolver from ${styles.bold(relativePath)}`);
@@ -99653,6 +99660,7 @@ async function loadFileContent(filePath) {
 			if (exportName === "default") {
 				const workflowResult = WorkflowSchema.safeParse(exportValue);
 				if (workflowResult.success) workflow = workflowResult.data;
+				else if (isSdkBranded(exportValue)) throw workflowResult.error;
 				continue;
 			}
 			const jobResult = WorkflowJobSchema.safeParse(exportValue);
@@ -99661,6 +99669,7 @@ async function loadFileContent(filePath) {
 				exportName,
 				sourceFile: filePath
 			});
+			else if (isSdkBranded(exportValue)) throw jobResult.error;
 		}
 	} catch (error) {
 		const relativePath = path$20.relative(process.cwd(), filePath);
@@ -100528,6 +100537,74 @@ async function bundleSingleResolver(resolver, outputDir, tsconfig, triggerContex
 	}));
 }
 
+//#endregion
+//#region src/cli/bundler/runtime-args.ts
+/**
+* Runtime args transformation for all services.
+*
+* Each service transforms server-side args/context into SDK-friendly format:
+* - Executor: server-side expression evaluated by platform before calling function
+* - Resolver: operationHook expression evaluated by platform before calling function
+* - Workflow: JS code embedded in bundled entry file (uses tailorUserMap directly)
+*
+* The user field mapping (server → SDK) shared across services is defined in
+* `@/parser/service/tailordb` as `tailorUserMap`.
+*/
+/**
+* Actor field transformation expression.
+*
+* Transforms the server's actor object to match the SDK's TailorActor type:
+*   server `attributeMap`  → SDK `attributes`
+*   server `attributes`    → SDK `attributeList`
+*   other fields           → passed through
+*   null/undefined actor   → null
+*/
+const ACTOR_TRANSFORM_EXPR = "actor: args.actor ? (({ attributeMap, attributes: attrList, ...rest }) => ({ ...rest, attributes: attributeMap, attributeList: attrList }))(args.actor) : null";
+/**
+* Build the JavaScript expression that transforms server-format executor event
+* args into SDK-format args at runtime.
+*
+* The Tailor Platform server delivers event args with server-side field names.
+* The SDK exposes different field names to user code. This function produces a
+* JavaScript expression string that performs the mapping when evaluated
+* server-side.
+* @param triggerKind - The trigger kind discriminant from the parsed executor
+* @param env - Application env record to embed in the expression
+* @returns A JavaScript expression string, e.g. `({ ...args, ... })`
+*/
+function buildExecutorArgsExpr(triggerKind, env) {
+	const envExpr = `env: ${JSON.stringify(env)}`;
+	switch (triggerKind) {
+		case "schedule":
+		case "recordCreated":
+		case "recordUpdated":
+		case "recordDeleted":
+		case "idpUserCreated":
+		case "idpUserUpdated":
+		case "idpUserDeleted":
+		case "authAccessTokenIssued":
+		case "authAccessTokenRefreshed":
+		case "authAccessTokenRevoked": return `({ ...args, appNamespace: args.namespaceName, ${ACTOR_TRANSFORM_EXPR}, ${envExpr} })`;
+		case "resolverExecuted": return `({ ...args, appNamespace: args.namespaceName, ${ACTOR_TRANSFORM_EXPR}, success: !!args.succeeded, result: args.succeeded?.result.resolver, error: args.failed?.error, ${envExpr} })`;
+		case "incomingWebhook": return `({ ...args, appNamespace: args.namespaceName, rawBody: args.raw_body, ${envExpr} })`;
+		default: throw new Error(`Unknown trigger kind for args expression: ${triggerKind}`);
+	}
+}
+/**
+* Build the operationHook expression for resolver pipelines.
+*
+* Transforms server context to SDK resolver context:
+*   context.args        → input
+*   context.pipeline     → spread into result
+*   user (global var)    → TailorUser (via tailorUserMap: workspace_id→workspaceId, attribute_map→attributes, attributes→attributeList)
+*   env                 → injected as JSON
+* @param env - Application env record to embed in the expression
+* @returns A JavaScript expression string for the operationHook
+*/
+function buildResolverOperationHookExpr(env) {
+	return `({ ...context.pipeline, input: context.args, user: ${tailorUserMap}, env: ${JSON.stringify(env)} });`;
+}
+
 //#endregion
 //#region src/cli/bundler/workflow/source-transformer.ts
 /**
@@ -100796,10 +100873,10 @@ async function bundleSingleJob(job, allJobs, outputDir, tsconfig, env, triggerCo
 	const entryContent = ml`
     import { ${job.exportName} } from "${absoluteSourcePath}";
 
-    const env = ${JSON.stringify(env)};
-
     export async function main(input) {
-      return await ${job.exportName}.body(input, { env });
+      const env = ${JSON.stringify(env)};
+      const _user = ${tailorUserMap};
+      return await ${job.exportName}.body(input, { env, user: _user });
     }
   `;
 	fs$15.writeFileSync(entryPath, entryContent);
@@ -100876,12 +100953,17 @@ const BaseGeneratorConfigSchema = z.union([
 const CustomPluginSchema = z.object({
 	id: z.string(),
 	description: z.string(),
-	importPath: z.string(),
+	importPath: z.string().optional(),
 	pluginConfig: z.unknown().optional(),
-	processType: functionSchema.optional(),
-	processNamespace: functionSchema.optional(),
-	typeConfigRequired: z.union([z.boolean(), functionSchema]).optional()
-}).passthrough();
+	typeConfigRequired: z.union([z.boolean(), functionSchema]).optional(),
+	onTypeLoaded: functionSchema.optional(),
+	onNamespaceLoaded: functionSchema.optional(),
+	onTailorDBReady: functionSchema.optional(),
+	onResolverReady: functionSchema.optional(),
+	onExecutorReady: functionSchema.optional()
+}).passthrough().refine((p) => {
+	return !(p.onTypeLoaded || p.onNamespaceLoaded) || !!p.importPath;
+}, { message: "importPath is required when plugin has definition-time hooks (onTypeLoaded/onNamespaceLoaded)" });
 /**
 * Creates a PluginConfigSchema for custom plugins
 * @returns Plugin config schema that validates and transforms Plugin instances
@@ -100890,1584 +100972,6 @@ function createPluginConfigSchema() {
 	return CustomPluginSchema.transform((plugin) => plugin);
 }
 
-//#endregion
-//#region src/cli/generator/types.ts
-/**
-* Type guard to check if a generator has a specific dependency.
-* @template D
-* @param generator - Code generator instance
-* @param dependency - Dependency kind to check
-* @returns True if the generator has the dependency
-*/
-function hasDependency(generator, dependency) {
-	return generator.dependencies.includes(dependency);
-}
-
-//#endregion
-//#region src/cli/generator/builtin/enum-constants/generate-enum-constants.ts
-/**
-* Generate enum constant definitions from collected metadata.
-* @param allEnums - All collected enum definitions
-* @returns Generated enum constant definitions
-*/
-function generateUnifiedEnumConstants(allEnums) {
-	if (allEnums.length === 0) return "";
-	const enumMap = /* @__PURE__ */ new Map();
-	for (const enumDef of allEnums) enumMap.set(enumDef.name, enumDef);
-	const enumDefs = Array.from(enumMap.values()).map((e) => {
-		const members = e.values.map((v) => {
-			return `  "${v.value.replace(/[-\s]/g, "_")}": "${v.value}"`;
-		}).join(",\n");
-		const hasDescriptions = e.values.some((v) => v.description);
-		let jsDoc = "";
-		if (e.fieldDescription || hasDescriptions) {
-			const lines = [];
-			if (e.fieldDescription) {
-				lines.push(` * ${e.fieldDescription}`);
-				if (hasDescriptions) lines.push(" *");
-			}
-			if (hasDescriptions) {
-				const propertyDocs = e.values.map((v) => {
-					return ` * @property ${[v.value.replace(/[-\s]/g, "_"), v.description].filter(Boolean).join(" - ")}`;
-				});
-				lines.push(...propertyDocs);
-			}
-			if (lines.length > 0) jsDoc = `/**\n${lines.join("\n")}\n */\n`;
-		}
-		return `${`${jsDoc}export const ${e.name} = {\n${members}\n} as const;`}\n${`export type ${e.name} = (typeof ${e.name})[keyof typeof ${e.name}];`}`;
-	}).join("\n\n");
-	if (!enumDefs) return "";
-	return enumDefs + "\n";
-}
-
-//#endregion
-//#region src/cli/generator/builtin/enum-constants/process-enum-type.ts
-function capitalizeFirst(str) {
-	return str.charAt(0).toUpperCase() + str.slice(1);
-}
-function collectEnums(type) {
-	const enums = [];
-	for (const [fieldName, parsedField] of Object.entries(type.fields)) {
-		if (parsedField.config.type === "enum" && parsedField.config.allowedValues) {
-			const enumTypeName = `${type.name}${capitalizeFirst(fieldName)}`;
-			enums.push({
-				name: enumTypeName,
-				values: parsedField.config.allowedValues,
-				fieldDescription: parsedField.config.description
-			});
-		}
-		if (parsedField.config.type === "nested" && parsedField.config.fields) {
-			for (const [nestedFieldName, nestedFieldConfig] of Object.entries(parsedField.config.fields)) if (nestedFieldConfig.type === "enum" && nestedFieldConfig.allowedValues) {
-				const fullFieldName = `${fieldName}${capitalizeFirst(nestedFieldName)}`;
-				const enumTypeName = `${type.name}${capitalizeFirst(fullFieldName)}`;
-				enums.push({
-					name: enumTypeName,
-					values: nestedFieldConfig.allowedValues,
-					fieldDescription: nestedFieldConfig.description
-				});
-			}
-		}
-	}
-	return enums;
-}
-/**
-* Process a TailorDB type and extract enum metadata.
-* @param type - The parsed TailorDB type to process
-* @returns Enum constant metadata for the type
-*/
-async function processEnumType(type) {
-	const enums = collectEnums(type);
-	return {
-		name: type.name,
-		enums
-	};
-}
-
-//#endregion
-//#region src/cli/generator/builtin/enum-constants/index.ts
-const EnumConstantsGeneratorID = "@tailor-platform/enum-constants";
-/**
-* Create an enum constants generator from TailorDB type definitions.
-* @param options - Generator options
-* @param options.distPath - Output file path
-* @returns TailorDB generator instance
-*/
-function createEnumConstantsGenerator(options) {
-	return {
-		id: EnumConstantsGeneratorID,
-		description: "Generates enum constants from TailorDB type definitions",
-		dependencies: ["tailordb"],
-		async processType(args) {
-			return await processEnumType(args.type);
-		},
-		async processTailorDBNamespace(args) {
-			const allEnums = [];
-			for (const enumConstantMetadata of Object.values(args.types)) allEnums.push(...enumConstantMetadata.enums);
-			return {
-				namespace: args.namespace,
-				enums: allEnums
-			};
-		},
-		aggregate(args) {
-			const files = [];
-			const allEnums = [];
-			for (const nsResult of args.input.tailordb) if (nsResult.types && nsResult.types.enums.length > 0) allEnums.push(...nsResult.types.enums);
-			if (allEnums.length > 0) {
-				const content = generateUnifiedEnumConstants(allEnums);
-				files.push({
-					path: options.distPath,
-					content
-				});
-			}
-			return { files };
-		}
-	};
-}
-
-//#endregion
-//#region src/cli/generator/builtin/file-utils/generate-file-utils.ts
-/**
-* Generate unified file utility functions from collected metadata.
-* @param namespaceData - Namespace data with file utility metadata
-* @returns Generated file utility code
-*/
-function generateUnifiedFileUtils(namespaceData) {
-	if (namespaceData.length === 0) return "";
-	const typeNamespaceMap = /* @__PURE__ */ new Map();
-	const typeFieldsMap = /* @__PURE__ */ new Map();
-	for (const { namespace, types: types$2 } of namespaceData) for (const type of types$2) {
-		typeNamespaceMap.set(type.name, namespace);
-		typeFieldsMap.set(type.name, type.fileFields);
-	}
-	if (typeNamespaceMap.size === 0) return "";
-	return [
-		ml`
-      export interface TypeWithFiles {
-      ${Array.from(typeFieldsMap.entries()).map(([typeName, fields]) => {
-			return `  ${typeName}: {\n    fields: ${fields.map((field) => `"${field}"`).join(" | ")};\n  };`;
-		}).join("\n")}
-      }
-    ` + "\n",
-		ml`
-      const namespaces: Record<keyof TypeWithFiles, string> = {
-      ${Array.from(typeNamespaceMap.entries()).map(([typeName, namespace]) => `  ${typeName}: "${namespace}"`).join(",\n")},
-      };
-    ` + "\n",
-		ml`
-      export async function downloadFile<T extends keyof TypeWithFiles>(
-        type: T,
-        field: TypeWithFiles[T]["fields"],
-        recordId: string,
-      ) {
-        return await tailordb.file.download(namespaces[type], type, field, recordId);
-      }
-    ` + "\n",
-		ml`
-      export async function uploadFile<T extends keyof TypeWithFiles>(
-        type: T,
-        field: TypeWithFiles[T]["fields"],
-        recordId: string,
-        data: string | ArrayBuffer | Uint8Array<ArrayBufferLike> | number[],
-        options?: FileUploadOptions,
-      ): Promise<FileUploadResponse> {
-        return await tailordb.file.upload(namespaces[type], type, field, recordId, data, options);
-      }
-    ` + "\n",
-		ml`
-      export async function deleteFile<T extends keyof TypeWithFiles>(
-        type: T,
-        field: TypeWithFiles[T]["fields"],
-        recordId: string,
-      ): Promise<void> {
-        return await tailordb.file.delete(namespaces[type], type, field, recordId);
-      }
-    ` + "\n",
-		ml`
-      export async function getFileMetadata<T extends keyof TypeWithFiles>(
-        type: T,
-        field: TypeWithFiles[T]["fields"],
-        recordId: string,
-      ): Promise<FileMetadata> {
-        return await tailordb.file.getMetadata(namespaces[type], type, field, recordId);
-      }
-    ` + "\n",
-		ml`
-      export async function openFileDownloadStream<T extends keyof TypeWithFiles>(
-        type: T,
-        field: TypeWithFiles[T]["fields"],
-        recordId: string,
-      ): Promise<FileStreamIterator> {
-        return await tailordb.file.openDownloadStream(namespaces[type], type, field, recordId);
-      }
-    ` + "\n"
-	].join("\n");
-}
-
-//#endregion
-//#region src/cli/generator/builtin/file-utils/process-file-type.ts
-/**
-* Process a TailorDB type and extract file field metadata.
-* @param type - The parsed TailorDB type to process
-* @returns File utility metadata for the type
-*/
-async function processFileType(type) {
-	const fileFields = [];
-	if (type.files) for (const fileFieldName of Object.keys(type.files)) fileFields.push(fileFieldName);
-	return {
-		name: type.name,
-		fileFields
-	};
-}
-
-//#endregion
-//#region src/cli/generator/builtin/file-utils/index.ts
-const FileUtilsGeneratorID = "@tailor-platform/file-utils";
-/**
-* Create a file utilities generator from TailorDB type definitions.
-* @param options - Generator options
-* @param options.distPath - Output file path
-* @returns TailorDB generator instance
-*/
-function createFileUtilsGenerator(options) {
-	return {
-		id: FileUtilsGeneratorID,
-		description: "Generates TypeWithFiles interface from TailorDB type definitions",
-		dependencies: ["tailordb"],
-		async processType(args) {
-			return await processFileType(args.type);
-		},
-		async processTailorDBNamespace(args) {
-			const typesWithFiles = Object.values(args.types).filter((t) => t.fileFields.length > 0);
-			if (typesWithFiles.length === 0) return "";
-			return JSON.stringify({
-				namespace: args.namespace,
-				types: typesWithFiles
-			});
-		},
-		aggregate(args) {
-			const files = [];
-			const allNamespaceData = [];
-			for (const nsResult of args.input.tailordb) if (nsResult.types) try {
-				const parsed = JSON.parse(nsResult.types);
-				if (parsed.namespace && parsed.types) allNamespaceData.push(parsed);
-			} catch {}
-			if (allNamespaceData.length > 0) {
-				const content = generateUnifiedFileUtils(allNamespaceData);
-				if (content) files.push({
-					path: options.distPath,
-					content
-				});
-			}
-			return { files };
-		}
-	};
-}
-
-//#endregion
-//#region src/cli/generator/builtin/kysely-type/type-processor.ts
-/**
-* Get the enum type definition.
-* @param fieldConfig - The field configuration
-* @returns The enum type as a string union
-*/
-function getEnumType(fieldConfig) {
-	const allowedValues = fieldConfig.allowedValues;
-	if (allowedValues && Array.isArray(allowedValues)) return allowedValues.map((v) => {
-		return `"${typeof v === "string" ? v : v.value}"`;
-	}).join(" | ");
-	return "string";
-}
-/**
-* Get the nested object type definition.
-* @param fieldConfig - The field configuration
-* @returns The nested type with used utility types
-*/
-function getNestedType(fieldConfig) {
-	const fields = fieldConfig.fields;
-	if (!fields || typeof fields !== "object") return {
-		type: "string",
-		usedUtilityTypes: {
-			Timestamp: false,
-			Serial: false
-		}
-	};
-	const fieldResults = Object.entries(fields).map(([fieldName, nestedOperatorFieldConfig]) => ({
-		fieldName,
-		...generateFieldType(nestedOperatorFieldConfig)
-	}));
-	const fieldTypes = fieldResults.map((result) => `${result.fieldName}: ${result.type}`);
-	const aggregatedUtilityTypes = fieldResults.reduce((acc, result) => ({
-		Timestamp: acc.Timestamp || result.usedUtilityTypes.Timestamp,
-		Serial: acc.Serial || result.usedUtilityTypes.Serial
-	}), {
-		Timestamp: false,
-		Serial: false
-	});
-	return {
-		type: `{\n  ${fieldTypes.join(";\n  ")}${fieldTypes.length > 0 ? ";" : ""}\n}`,
-		usedUtilityTypes: aggregatedUtilityTypes
-	};
-}
-/**
-* Get the base Kysely type for a field (without array/null modifiers).
-* @param fieldConfig - The field configuration
-* @returns The base type with used utility types
-*/
-function getBaseType(fieldConfig) {
-	const fieldType = fieldConfig.type;
-	const usedUtilityTypes = {
-		Timestamp: false,
-		Serial: false
-	};
-	let type;
-	switch (fieldType) {
-		case "uuid":
-		case "string":
-			type = "string";
-			break;
-		case "integer":
-		case "float":
-			type = "number";
-			break;
-		case "date":
-		case "datetime":
-			usedUtilityTypes.Timestamp = true;
-			type = "Timestamp";
-			break;
-		case "bool":
-		case "boolean":
-			type = "boolean";
-			break;
-		case "enum":
-			type = getEnumType(fieldConfig);
-			break;
-		case "nested": return getNestedType(fieldConfig);
-		default:
-			type = "string";
-			break;
-	}
-	return {
-		type,
-		usedUtilityTypes
-	};
-}
-/**
-* Generate the complete field type including array and null modifiers.
-* @param fieldConfig - The field configuration
-* @returns The complete field type with used utility types
-*/
-function generateFieldType(fieldConfig) {
-	const baseTypeResult = getBaseType(fieldConfig);
-	const usedUtilityTypes = { ...baseTypeResult.usedUtilityTypes };
-	const isArray$1 = fieldConfig.array === true;
-	const isNullable = fieldConfig.required !== true;
-	let finalType = baseTypeResult.type;
-	if (isArray$1) finalType = fieldConfig.type === "enum" ? `(${baseTypeResult.type})[]` : `${baseTypeResult.type}[]`;
-	if (isNullable) finalType = `${finalType} | null`;
-	if (fieldConfig.serial) {
-		usedUtilityTypes.Serial = true;
-		finalType = `Serial<${finalType}>`;
-	}
-	if (fieldConfig.hooks?.create) finalType = `Generated<${finalType}>`;
-	return {
-		type: finalType,
-		usedUtilityTypes
-	};
-}
-/**
-* Generate the table interface.
-* @param type - The parsed TailorDB type
-* @returns The type definition and used utility types
-*/
-function generateTableInterface(type) {
-	const fieldResults = Object.entries(type.fields).filter(([fieldName]) => fieldName !== "id").map(([fieldName, parsedField]) => ({
-		fieldName,
-		...generateFieldType(parsedField.config)
-	}));
-	const fields = ["id: Generated<string>;", ...fieldResults.map((result) => `${result.fieldName}: ${result.type};`)];
-	const aggregatedUtilityTypes = fieldResults.reduce((acc, result) => ({
-		Timestamp: acc.Timestamp || result.usedUtilityTypes.Timestamp,
-		Serial: acc.Serial || result.usedUtilityTypes.Serial
-	}), {
-		Timestamp: false,
-		Serial: false
-	});
-	return {
-		typeDef: ml`
-    ${type.name}: {
-      ${fields.join("\n")}
-    }
-  `,
-		usedUtilityTypes: aggregatedUtilityTypes
-	};
-}
-/**
-* Convert a TailorDBType into KyselyTypeMetadata.
-* @param type - Parsed TailorDB type
-* @returns Generated Kysely type metadata
-*/
-async function processKyselyType(type) {
-	const result = generateTableInterface(type);
-	return {
-		name: type.name,
-		typeDef: result.typeDef,
-		usedUtilityTypes: result.usedUtilityTypes
-	};
-}
-/**
-* Generate unified types file from multiple namespaces.
-* @param namespaceData - Namespace metadata
-* @returns Generated types file contents
-*/
-function generateUnifiedKyselyTypes(namespaceData) {
-	if (namespaceData.length === 0) return "";
-	const globalUsedUtilityTypes = namespaceData.reduce((acc, ns) => ({
-		Timestamp: acc.Timestamp || ns.usedUtilityTypes.Timestamp,
-		Serial: acc.Serial || ns.usedUtilityTypes.Serial
-	}), {
-		Timestamp: false,
-		Serial: false
-	});
-	const utilityTypeImports = ["type Generated"];
-	if (globalUsedUtilityTypes.Timestamp) utilityTypeImports.push("type Timestamp");
-	if (globalUsedUtilityTypes.Serial) utilityTypeImports.push("type Serial");
-	return [
-		ml`
-    import {
-      createGetDB,
-      ${utilityTypeImports.join(",\n")},
-      type NamespaceDB,
-      type NamespaceInsertable,
-      type NamespaceSelectable,
-      type NamespaceTable,
-      type NamespaceTableName,
-      type NamespaceTransaction,
-      type NamespaceUpdateable,
-    } from "@tailor-platform/sdk/kysely";
-  `,
-		`export interface Namespace {\n${namespaceData.map(({ namespace, types: types$2 }) => {
-			return `  "${namespace}": {\n${types$2.map((type) => {
-				return type.typeDef.split("\n").map((line) => line.trim() ? `    ${line}` : "").join("\n");
-			}).join("\n\n")}\n  }`;
-		}).join(",\n")}\n}`,
-		ml`
-    export const getDB = createGetDB<Namespace>();
-
-    export type DB<N extends keyof Namespace = keyof Namespace> = NamespaceDB<Namespace, N>;
-  `,
-		ml`
-    export type Transaction<K extends keyof Namespace | DB = keyof Namespace> =
-      NamespaceTransaction<Namespace, K>;
-
-    type TableName = NamespaceTableName<Namespace>;
-    export type Table<T extends TableName> = NamespaceTable<Namespace, T>;
-
-    export type Insertable<T extends TableName> = NamespaceInsertable<Namespace, T>;
-    export type Selectable<T extends TableName> = NamespaceSelectable<Namespace, T>;
-    export type Updateable<T extends TableName> = NamespaceUpdateable<Namespace, T>;
-  `
-	].join("\n\n") + "\n";
-}
-
-//#endregion
-//#region src/cli/generator/builtin/kysely-type/index.ts
-const KyselyGeneratorID = "@tailor-platform/kysely-type";
-/**
-* Create a Kysely type generator for TailorDB types.
-* @param options - Generator options
-* @param options.distPath - Output file path
-* @returns TailorDB generator instance
-*/
-function createKyselyGenerator(options) {
-	return {
-		id: KyselyGeneratorID,
-		description: "Generates Kysely type definitions for TailorDB types",
-		dependencies: ["tailordb"],
-		async processType(args) {
-			return await processKyselyType(args.type);
-		},
-		async processTailorDBNamespace(args) {
-			const typesList = Object.values(args.types);
-			const usedUtilityTypes = typesList.reduce((acc, type) => ({
-				Timestamp: acc.Timestamp || type.usedUtilityTypes.Timestamp,
-				Serial: acc.Serial || type.usedUtilityTypes.Serial
-			}), {
-				Timestamp: false,
-				Serial: false
-			});
-			return {
-				namespace: args.namespace,
-				types: typesList,
-				usedUtilityTypes
-			};
-		},
-		aggregate(args) {
-			const files = [];
-			const allNamespaceData = [];
-			for (const nsResult of args.input.tailordb) if (nsResult.types && nsResult.types.types.length > 0) allNamespaceData.push(nsResult.types);
-			if (allNamespaceData.length > 0) {
-				const content = generateUnifiedKyselyTypes(allNamespaceData);
-				files.push({
-					path: options.distPath,
-					content
-				});
-			}
-			return { files };
-		}
-	};
-}
-
-//#endregion
-//#region src/cli/generator/builtin/seed/idp-user-processor.ts
-/**
-* Processes auth configuration to generate IdP user seed metadata
-* @param auth - Auth configuration from generator
-* @returns IdP user metadata or undefined if not applicable
-*/
-function processIdpUser(auth) {
-	if (auth.idProvider?.kind !== "BuiltInIdP" || !auth.userProfile) return;
-	const { typeName, usernameField } = auth.userProfile;
-	return {
-		name: "_User",
-		dependencies: [typeName],
-		dataFile: "data/_User.jsonl",
-		idpNamespace: auth.idProvider.namespace,
-		schema: {
-			usernameField,
-			userTypeName: typeName
-		}
-	};
-}
-/**
-* Generates the server-side IDP seed script code for testExecScript execution.
-* Uses the global tailor.idp.Client - no bundling required.
-* @param idpNamespace - The IDP namespace name
-* @returns Script code string
-*/
-function generateIdpSeedScriptCode(idpNamespace) {
-	return ml`
-    export async function main(input) {
-      const client = new tailor.idp.Client({ namespace: "${idpNamespace}" });
-      const errors = [];
-      let processed = 0;
-
-      for (let i = 0; i < input.users.length; i++) {
-        try {
-          await client.createUser(input.users[i]);
-          processed++;
-          console.log(\`[_User] \${i + 1}/\${input.users.length}: \${input.users[i].name}\`);
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          errors.push(\`Row \${i} (\${input.users[i].name}): \${message}\`);
-          console.error(\`[_User] Row \${i} failed: \${message}\`);
-        }
-      }
-
-      return {
-        success: errors.length === 0,
-        processed,
-        errors,
-      };
-    }
-  `;
-}
-/**
-* Generates the server-side IDP truncation script code for testExecScript execution.
-* Lists all users with pagination and deletes each one.
-* @param idpNamespace - The IDP namespace name
-* @returns Script code string
-*/
-function generateIdpTruncateScriptCode(idpNamespace) {
-	return ml`
-    export async function main() {
-      const client = new tailor.idp.Client({ namespace: "${idpNamespace}" });
-      const errors = [];
-      let deleted = 0;
-
-      // List all users with pagination
-      let nextToken = undefined;
-      const allUsers = [];
-      do {
-        const response = await client.users(nextToken ? { nextToken } : undefined);
-        allUsers.push(...(response.users || []));
-        nextToken = response.nextToken;
-      } while (nextToken);
-
-      console.log(\`Found \${allUsers.length} IDP users to delete\`);
-
-      for (const user of allUsers) {
-        try {
-          await client.deleteUser(user.id);
-          deleted++;
-          console.log(\`[_User] Deleted \${deleted}/\${allUsers.length}: \${user.name}\`);
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          errors.push(\`User \${user.id} (\${user.name}): \${message}\`);
-          console.error(\`[_User] Delete failed for \${user.name}: \${message}\`);
-        }
-      }
-
-      return {
-        success: errors.length === 0,
-        deleted,
-        total: allUsers.length,
-        errors,
-      };
-    }
-  `;
-}
-/**
-* Generates the schema file content for IdP users with foreign key
-* @param usernameField - Username field name
-* @param userTypeName - TailorDB user type name
-* @returns Schema file contents
-*/
-function generateIdpUserSchemaFile(usernameField, userTypeName) {
-	return ml`
-    import { t } from "@tailor-platform/sdk";
-    import { createStandardSchema } from "@tailor-platform/sdk/test";
-    import { defineSchema } from "@toiroakr/lines-db";
-
-    const schemaType = t.object({
-      name: t.string(),
-      password: t.string(),
-    });
-
-    // Simple identity hook for _User (no TailorDB backing type)
-    const hook = <T>(data: unknown) => data as T;
-
-    export const schema = defineSchema(
-      createStandardSchema(schemaType, hook),
-      {
-        primaryKey: "name",
-        indexes: [
-          { name: "_user_name_unique_idx", columns: ["name"], unique: true },
-        ],
-        foreignKeys: [
-          {
-            column: "name",
-            references: {
-              table: "${userTypeName}",
-              column: "${usernameField}",
-            },
-          },
-        ],
-      }
-    );
-
-    `;
-}
-
-//#endregion
-//#region src/cli/generator/builtin/seed/lines-db-processor.ts
-/**
-* Processes TailorDB types to generate lines-db metadata
-* @param type - Parsed TailorDB type
-* @param source - Source file info
-* @returns Generated lines-db metadata
-*/
-function processLinesDb(type, source) {
-	if (isPluginGeneratedType(source)) return processLinesDbForPluginType(type, source);
-	if (!source.filePath) throw new Error(`Missing source info for type ${type.name}`);
-	if (!source.exportName) throw new Error(`Missing export name for type ${type.name}`);
-	const { optionalFields, omitFields, indexes, foreignKeys } = extractFieldMetadata(type);
-	return {
-		typeName: type.name,
-		exportName: source.exportName,
-		importPath: source.filePath,
-		optionalFields,
-		omitFields,
-		foreignKeys,
-		indexes
-	};
-}
-/**
-* Process lines-db metadata for plugin-generated types
-* @param type - Parsed TailorDB type
-* @param source - Plugin-generated type source info
-* @returns Generated lines-db metadata with plugin source
-*/
-function processLinesDbForPluginType(type, source) {
-	const { optionalFields, omitFields, indexes, foreignKeys } = extractFieldMetadata(type);
-	return {
-		typeName: type.name,
-		exportName: source.exportName,
-		importPath: "",
-		optionalFields,
-		omitFields,
-		foreignKeys,
-		indexes,
-		pluginSource: source
-	};
-}
-/**
-* Extract field metadata from TailorDB type
-* @param type - Parsed TailorDB type
-* @returns Field metadata including optional fields, omit fields, indexes, and foreign keys
-*/
-function extractFieldMetadata(type) {
-	const optionalFields = ["id"];
-	const omitFields = [];
-	const indexes = [];
-	const foreignKeys = [];
-	for (const [fieldName, field] of Object.entries(type.fields)) {
-		if (field.config.hooks?.create) optionalFields.push(fieldName);
-		if (field.config.serial) omitFields.push(fieldName);
-		if (field.config.unique) indexes.push({
-			name: `${type.name.toLowerCase()}_${fieldName}_unique_idx`,
-			columns: [fieldName],
-			unique: true
-		});
-	}
-	if (type.indexes) for (const [indexName, indexDef] of Object.entries(type.indexes)) indexes.push({
-		name: indexName,
-		columns: indexDef.fields,
-		unique: indexDef.unique
-	});
-	for (const [fieldName, field] of Object.entries(type.fields)) if (field.relation) foreignKeys.push({
-		column: fieldName,
-		references: {
-			table: field.relation.targetType,
-			column: field.relation.key
-		}
-	});
-	return {
-		optionalFields,
-		omitFields,
-		indexes,
-		foreignKeys
-	};
-}
-/**
-* Generate schema options code for lines-db
-* @param foreignKeys - Foreign key definitions
-* @param indexes - Index definitions
-* @returns Schema options code string
-*/
-function generateSchemaOptions(foreignKeys, indexes) {
-	const schemaOptions = [];
-	if (foreignKeys.length > 0) {
-		schemaOptions.push(`foreignKeys: [`);
-		foreignKeys.forEach((fk) => {
-			schemaOptions.push(`  ${JSON.stringify(fk)},`);
-		});
-		schemaOptions.push(`],`);
-	}
-	if (indexes.length > 0) {
-		schemaOptions.push(`indexes: [`);
-		indexes.forEach((index$1) => {
-			schemaOptions.push(`  ${JSON.stringify(index$1)},`);
-		});
-		schemaOptions.push("],");
-	}
-	return schemaOptions.length > 0 ? [
-		"\n  {",
-		...schemaOptions.map((option) => `    ${option}`),
-		"  }"
-	].join("\n") : "";
-}
-/**
-* Generates the schema file content for lines-db (for user-defined types with import)
-* @param metadata - lines-db metadata
-* @param importPath - Import path for the TailorDB type
-* @returns Schema file contents
-*/
-function generateLinesDbSchemaFile(metadata, importPath) {
-	const { exportName, optionalFields, omitFields, foreignKeys, indexes } = metadata;
-	return ml`
-    import { t } from "@tailor-platform/sdk";
-    import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
-    import { defineSchema } from "@toiroakr/lines-db";
-    import { ${exportName} } from "${importPath}";
-
-    ${ml`
-    const schemaType = t.object({
-      ...${exportName}.pickFields(${JSON.stringify(optionalFields)}, { optional: true }),
-      ...${exportName}.omitFields(${JSON.stringify([...optionalFields, ...omitFields])}),
-    });
-    `}
-
-    const hook = createTailorDBHook(${exportName});
-
-    export const schema = defineSchema(
-      createStandardSchema(schemaType, hook),${generateSchemaOptions(foreignKeys, indexes)}
-    );
-
-    `;
-}
-/**
-* Generates the schema file content using getGeneratedType API
-* (for plugin-generated types)
-* @param metadata - lines-db metadata (must have pluginSource)
-* @param params - Plugin import paths
-* @returns Schema file contents
-*/
-function generateLinesDbSchemaFileWithPluginAPI(metadata, params) {
-	const { typeName, exportName, optionalFields, omitFields, foreignKeys, indexes, pluginSource } = metadata;
-	if (!pluginSource) throw new Error(`pluginSource is required for plugin-generated type "${typeName}"`);
-	const { configImportPath, originalImportPath } = params;
-	const schemaTypeCode = ml`
-    const schemaType = t.object({
-      ...${exportName}.pickFields(${JSON.stringify(optionalFields)}, { optional: true }),
-      ...${exportName}.omitFields(${JSON.stringify([...optionalFields, ...omitFields])}),
-    });
-    `;
-	const schemaOptionsCode = generateSchemaOptions(foreignKeys, indexes);
-	if (pluginSource.originalExportName && originalImportPath && pluginSource.generatedTypeKind) return ml`
-    import { join } from "node:path";
-    import { t } from "@tailor-platform/sdk";
-    import { getGeneratedType } from "@tailor-platform/sdk/plugin";
-    import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
-    import { defineSchema } from "@toiroakr/lines-db";
-    import { ${pluginSource.originalExportName} } from "${originalImportPath}";
-
-    const configPath = join(import.meta.dirname, "${configImportPath}");
-    const ${exportName} = await getGeneratedType(configPath, "${pluginSource.pluginId}", ${pluginSource.originalExportName}, "${pluginSource.generatedTypeKind}");
-
-    ${schemaTypeCode}
-
-    const hook = createTailorDBHook(${exportName});
-
-    export const schema = defineSchema(
-      createStandardSchema(schemaType, hook),${schemaOptionsCode}
-    );
-
-    `;
-	if (!pluginSource.generatedTypeKind) throw new Error(`Namespace plugin "${pluginSource.pluginId}" must provide generatedTypeKind for type "${typeName}"`);
-	return ml`
-    import { join } from "node:path";
-    import { t } from "@tailor-platform/sdk";
-    import { getGeneratedType } from "@tailor-platform/sdk/plugin";
-    import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
-    import { defineSchema } from "@toiroakr/lines-db";
-
-    const configPath = join(import.meta.dirname, "${configImportPath}");
-    const ${exportName} = await getGeneratedType(configPath, "${pluginSource.pluginId}", null, "${pluginSource.generatedTypeKind}");
-
-    ${schemaTypeCode}
-
-    const hook = createTailorDBHook(${exportName});
-
-    export const schema = defineSchema(
-      createStandardSchema(schemaType, hook),${schemaOptionsCode}
-    );
-
-    `;
-}
-
-//#endregion
-//#region src/cli/generator/builtin/seed/seed-type-processor.ts
-/**
-* Processes TailorDB types to extract seed type information
-* @param type - Parsed TailorDB type
-* @param namespace - Namespace of the type
-* @returns Seed type information
-*/
-function processSeedTypeInfo(type, namespace) {
-	const dependencies = Array.from(Object.values(type.fields).reduce((set$1, field) => {
-		const targetType = field.relation?.targetType ?? field.config.foreignKeyType;
-		if (targetType && targetType !== type.name) set$1.add(targetType);
-		return set$1;
-	}, /* @__PURE__ */ new Set()));
-	return {
-		name: type.name,
-		namespace,
-		dependencies,
-		dataFile: `data/${type.name}.jsonl`
-	};
-}
-
-//#endregion
-//#region src/cli/generator/builtin/seed/index.ts
-const SeedGeneratorID = "@tailor-platform/seed";
-/**
-* Generate the IdP user seed function code using tailor.idp.Client via testExecScript
-* @param hasIdpUser - Whether IdP user is included
-* @param idpNamespace - The IDP namespace name
-* @returns JavaScript code for IdP user seeding function
-*/
-function generateIdpUserSeedFunction(hasIdpUser, idpNamespace) {
-	if (!hasIdpUser || !idpNamespace) return "";
-	return ml`
-    // Seed _User via tailor.idp.Client (server-side)
-    const seedIdpUser = async () => {
-      console.log(styleText("cyan", "  Seeding _User via tailor.idp.Client..."));
-      const dataDir = join(configDir, "data");
-      const data = loadSeedData(dataDir, ["_User"]);
-      const rows = data["_User"] || [];
-      if (rows.length === 0) {
-        console.log(styleText("dim", "    No _User data to seed"));
-        return { success: true };
-      }
-      console.log(styleText("dim", \`    Processing \${rows.length} _User records...\`));
-
-      const idpSeedCode = \/* js *\/\`${generateIdpSeedScriptCode(idpNamespace).replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`;
-
-      const result = await executeScript({
-        client: operatorClient,
-        workspaceId,
-        name: "seed-idp-user.ts",
-        code: idpSeedCode,
-        arg: JSON.stringify({ users: rows }),
-        invoker: {
-          namespace: authNamespace,
-          machineUserName,
-        },
-      });
-
-      if (result.logs) {
-        for (const line of result.logs.split("\\n").filter(Boolean)) {
-          console.log(styleText("dim", \`    \${line}\`));
-        }
-      }
-
-      if (result.success) {
-        let parsed;
-        try {
-          parsed = JSON.parse(result.result || "{}");
-        } catch (e) {
-          console.error(styleText("red", \`    ✗ Failed to parse seed result: \${e.message}\`));
-          return { success: false };
-        }
-
-        if (parsed.processed) {
-          console.log(styleText("green", \`    ✓ _User: \${parsed.processed} rows processed\`));
-        }
-
-        if (!parsed.success) {
-          const errors = Array.isArray(parsed.errors) ? parsed.errors : [];
-          for (const err of errors) {
-            console.error(styleText("red", \`    ✗ \${err}\`));
-          }
-          return { success: false };
-        }
-
-        return { success: true };
-      } else {
-        console.error(styleText("red", \`    ✗ Seed failed: \${result.error}\`));
-        return { success: false };
-      }
-    };
-  `;
-}
-/**
-* Generate the IdP user seed call code
-* @param hasIdpUser - Whether IdP user is included
-* @returns JavaScript code for calling IdP user seeding
-*/
-function generateIdpUserSeedCall(hasIdpUser) {
-	if (!hasIdpUser) return "";
-	return ml`
-    // Seed _User if included and not skipped
-    const shouldSeedUser = !skipIdp && (!entitiesToProcess || entitiesToProcess.includes("_User"));
-    if (hasIdpUser && shouldSeedUser) {
-      const result = await seedIdpUser();
-      if (!result.success) {
-        allSuccess = false;
-      }
-    }
-  `;
-}
-/**
-* Generate the IdP user truncation function code using tailor.idp.Client via testExecScript
-* @param hasIdpUser - Whether IdP user is included
-* @param idpNamespace - The IDP namespace name
-* @returns JavaScript code for IdP user truncation function
-*/
-function generateIdpUserTruncateFunction(hasIdpUser, idpNamespace) {
-	if (!hasIdpUser || !idpNamespace) return "";
-	return ml`
-    // Truncate _User via tailor.idp.Client (server-side)
-    const truncateIdpUser = async () => {
-      console.log(styleText("cyan", "Truncating _User via tailor.idp.Client..."));
-
-      const idpTruncateCode = \/* js *\/\`${generateIdpTruncateScriptCode(idpNamespace).replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`;
-
-      const result = await executeScript({
-        client: operatorClient,
-        workspaceId,
-        name: "truncate-idp-user.ts",
-        code: idpTruncateCode,
-        arg: JSON.stringify({}),
-        invoker: {
-          namespace: authNamespace,
-          machineUserName,
-        },
-      });
-
-      if (result.logs) {
-        for (const line of result.logs.split("\\n").filter(Boolean)) {
-          console.log(styleText("dim", \`  \${line}\`));
-        }
-      }
-
-      if (result.success) {
-        let parsed;
-        try {
-          parsed = JSON.parse(result.result || "{}");
-        } catch (e) {
-          console.error(styleText("red", \`  ✗ Failed to parse truncation result: \${e.message}\`));
-          return { success: false };
-        }
-
-        if (parsed.deleted !== undefined) {
-          console.log(styleText("green", \`  ✓ _User: \${parsed.deleted} users deleted\`));
-        }
-
-        if (!parsed.success) {
-          const errors = Array.isArray(parsed.errors) ? parsed.errors : [];
-          for (const err of errors) {
-            console.error(styleText("red", \`  ✗ \${err}\`));
-          }
-          return { success: false };
-        }
-
-        return { success: true };
-      } else {
-        console.error(styleText("red", \`  ✗ Truncation failed: \${result.error}\`));
-        return { success: false };
-      }
-    };
-  `;
-}
-/**
-* Generate the IdP user truncation call code within the truncate block
-* @param hasIdpUser - Whether IdP user is included
-* @returns JavaScript code for calling IdP user truncation
-*/
-function generateIdpUserTruncateCall(hasIdpUser) {
-	if (!hasIdpUser) return "";
-	return ml`
-    // Truncate _User if applicable
-    const shouldTruncateUser = !skipIdp && !hasNamespace && (!hasTypes || entitiesToProcess.includes("_User"));
-    if (hasIdpUser && shouldTruncateUser) {
-      const truncResult = await truncateIdpUser();
-      if (!truncResult.success) {
-        console.error(styleText("red", "IDP user truncation failed."));
-        process.exit(1);
-      }
-    }
-  `;
-}
-/**
-* Generates the exec.mjs script content using testExecScript API for TailorDB types
-* and tailor.idp.Client for _User (IdP managed)
-* @param defaultMachineUserName - Default machine user name from generator config (can be overridden at runtime)
-* @param relativeConfigPath - Config path relative to exec script
-* @param namespaceConfigs - Namespace configurations with types and dependencies
-* @param hasIdpUser - Whether _User is included
-* @param idpNamespace - The IDP namespace name, or null if not applicable
-* @returns exec.mjs file contents
-*/
-function generateExecScript(defaultMachineUserName, relativeConfigPath, namespaceConfigs, hasIdpUser, idpNamespace) {
-	const namespaceEntitiesEntries = namespaceConfigs.map(({ namespace, types: types$2 }) => {
-		return `      "${namespace}": [\n${types$2.map((e) => `        "${e}",`).join("\n")}\n      ]`;
-	}).join(",\n");
-	const namespaceDepsEntries = namespaceConfigs.map(({ namespace, dependencies }) => {
-		return `      "${namespace}": {\n${Object.entries(dependencies).map(([type, deps]) => `        "${type}": [${deps.map((d) => `"${d}"`).join(", ")}]`).join(",\n")}\n      }`;
-	}).join(",\n");
-	return ml`
-    import { readFileSync } from "node:fs";
-    import { join } from "node:path";
-    import { parseArgs, styleText } from "node:util";
-    import { createInterface } from "node:readline";
-    import {
-      show,
-      truncate,
-      bundleSeedScript,
-      chunkSeedData,
-      executeScript,
-      initOperatorClient,
-      loadAccessToken,
-      loadWorkspaceId,
-    } from "@tailor-platform/sdk/cli";
-
-    // Parse command-line arguments
-    const { values, positionals } = parseArgs({
-      options: {
-        "machine-user": { type: "string", short: "m" },
-        namespace: { type: "string", short: "n" },
-        "skip-idp": { type: "boolean", default: false },
-        truncate: { type: "boolean", default: false },
-        yes: { type: "boolean", default: false },
-        profile: { type: "string", short: "p" },
-        help: { type: "boolean", short: "h", default: false },
-      },
-      allowPositionals: true,
-    });
-
-    if (values.help) {
-      console.log(\`
-    Usage: node exec.mjs [options] [types...]
-
-    Options:
-      -m, --machine-user <name> Machine user name for authentication (required if not configured)
-      -n, --namespace <ns>      Process all types in specified namespace (excludes _User)
-      --skip-idp                Skip IdP user (_User) entity
-      --truncate                Truncate tables before seeding
-      --yes                     Skip confirmation prompts (for truncate)
-      -p, --profile <name>      Workspace profile name
-      -h, --help                Show help
-
-    Examples:
-      node exec.mjs -m admin                            # Process all types with machine user
-      node exec.mjs --namespace <namespace>             # Process tailordb namespace only (no _User)
-      node exec.mjs User Order                          # Process specific types only
-      node exec.mjs --skip-idp                          # Process all except _User
-      node exec.mjs --truncate                          # Truncate all tables, then seed all
-      node exec.mjs --truncate --yes                    # Truncate all tables without confirmation, then seed all
-      node exec.mjs --truncate --namespace <namespace>  # Truncate tailordb, then seed tailordb
-      node exec.mjs --truncate User Order               # Truncate User and Order, then seed them
-      \`);
-      process.exit(0);
-    }
-
-    // Helper function to prompt for y/n confirmation
-    const promptConfirmation = (question) => {
-      const rl = createInterface({
-        input: process.stdin,
-        output: process.stdout,
-      });
-
-      return new Promise((resolve) => {
-        rl.question(styleText("yellow", question), (answer) => {
-          rl.close();
-          resolve(answer.toLowerCase().trim());
-        });
-      });
-    };
-
-    const configDir = import.meta.dirname;
-    const configPath = join(configDir, "${relativeConfigPath}");
-
-    // Determine machine user name (CLI argument takes precedence over config default)
-    const defaultMachineUser = ${defaultMachineUserName ? `"${defaultMachineUserName}"` : "undefined"};
-    const machineUserName = values["machine-user"] || defaultMachineUser;
-
-    if (!machineUserName) {
-      console.error(styleText("red", "Error: Machine user name is required."));
-      console.error(styleText("yellow", "Specify --machine-user <name> or configure machineUserName in generator options."));
-      process.exit(1);
-    }
-
-    // Entity configuration
-    const namespaceEntities = {
-${namespaceEntitiesEntries}
-    };
-    const namespaceDeps = {
-${namespaceDepsEntries}
-    };
-    const entities = Object.values(namespaceEntities).flat();
-    const hasIdpUser = ${String(hasIdpUser)};
-
-    // Determine which entities to process
-    let entitiesToProcess = null;
-
-    const hasNamespace = !!values.namespace;
-    const hasTypes = positionals.length > 0;
-    const skipIdp = values["skip-idp"];
-
-    // Validate mutually exclusive options
-    const optionCount = [hasNamespace, hasTypes].filter(Boolean).length;
-    if (optionCount > 1) {
-      console.error(styleText("red", "Error: Options --namespace and type names are mutually exclusive."));
-      process.exit(1);
-    }
-
-    // --skip-idp and --namespace are redundant (namespace already excludes _User)
-    if (skipIdp && hasNamespace) {
-      console.warn(styleText("yellow", "Warning: --skip-idp is redundant with --namespace (namespace filtering already excludes _User)."));
-    }
-
-    // Filter by namespace (automatically excludes _User as it has no namespace)
-    if (hasNamespace) {
-      const namespace = values.namespace;
-      entitiesToProcess = namespaceEntities[namespace];
-
-      if (!entitiesToProcess || entitiesToProcess.length === 0) {
-        console.error(styleText("red", \`Error: No entities found in namespace "\${namespace}"\`));
-        console.error(styleText("yellow", \`Available namespaces: \${Object.keys(namespaceEntities).join(", ")}\`));
-        process.exit(1);
-      }
-
-      console.log(styleText("cyan", \`Filtering by namespace: \${namespace}\`));
-      console.log(styleText("dim", \`Entities: \${entitiesToProcess.join(", ")}\`));
-    }
-
-    // Filter by specific types
-    if (hasTypes) {
-      const requestedTypes = positionals;
-      const notFoundTypes = [];
-      const allTypes = hasIdpUser ? [...entities, "_User"] : entities;
-
-      entitiesToProcess = requestedTypes.filter((type) => {
-        if (!allTypes.includes(type)) {
-          notFoundTypes.push(type);
-          return false;
-        }
-        return true;
-      });
-
-      if (notFoundTypes.length > 0) {
-        console.error(styleText("red", \`Error: The following types were not found: \${notFoundTypes.join(", ")}\`));
-        console.error(styleText("yellow", \`Available types: \${allTypes.join(", ")}\`));
-        process.exit(1);
-      }
-
-      console.log(styleText("cyan", \`Filtering by types: \${entitiesToProcess.join(", ")}\`));
-    }
-
-    // Apply --skip-idp filter
-    if (skipIdp) {
-      if (entitiesToProcess) {
-        entitiesToProcess = entitiesToProcess.filter((entity) => entity !== "_User");
-      } else {
-        entitiesToProcess = entities.filter((entity) => entity !== "_User");
-      }
-    }
-
-    // Get application info
-    const appInfo = await show({ configPath, profile: values.profile });
-    const authNamespace = appInfo.auth;
-
-    // Initialize operator client (once for all namespaces)
-    const accessToken = await loadAccessToken({ profile: values.profile, useProfile: true });
-    const workspaceId = await loadWorkspaceId({ profile: values.profile });
-    const operatorClient = await initOperatorClient(accessToken);
-
-    ${generateIdpUserTruncateFunction(hasIdpUser, idpNamespace)}
-
-    // Truncate tables if requested
-    if (values.truncate) {
-      const answer = values.yes ? "y" : await promptConfirmation("Are you sure you want to truncate? (y/n): ");
-      if (answer !== "y") {
-        console.log(styleText("yellow", "Truncate cancelled."));
-        process.exit(0);
-      }
-
-      console.log(styleText("cyan", "Truncating tables..."));
-
-      try {
-        if (hasNamespace) {
-          await truncate({
-            configPath,
-            profile: values.profile,
-            namespace: values.namespace,
-          });
-        } else if (hasTypes) {
-          const typesToTruncate = entitiesToProcess.filter((t) => t !== "_User");
-          if (typesToTruncate.length > 0) {
-            await truncate({
-              configPath,
-              profile: values.profile,
-              types: typesToTruncate,
-            });
-          } else {
-            console.log(styleText("dim", "No TailorDB types to truncate (only _User was specified)."));
-          }
-        } else {
-          await truncate({
-            configPath,
-            profile: values.profile,
-            all: true,
-          });
-        }
-      } catch (error) {
-        console.error(styleText("red", \`Truncate failed: \${error.message}\`));
-        process.exit(1);
-      }
-
-      ${generateIdpUserTruncateCall(hasIdpUser)}
-
-      console.log(styleText("green", "Truncate completed."));
-    }
-
-    console.log(styleText("cyan", "\\nStarting seed data generation..."));
-    if (skipIdp) {
-      console.log(styleText("dim", \`  Skipping IdP user (_User)\`));
-    }
-
-    // Load seed data from JSONL files
-    const loadSeedData = (dataDir, typeNames) => {
-      const data = {};
-      for (const typeName of typeNames) {
-        const jsonlPath = join(dataDir, \`\${typeName}.jsonl\`);
-        try {
-          const content = readFileSync(jsonlPath, "utf-8").trim();
-          if (content) {
-            data[typeName] = content.split("\\n").map((line) => JSON.parse(line));
-          } else {
-            data[typeName] = [];
-          }
-        } catch (error) {
-          if (error.code === "ENOENT") {
-            data[typeName] = [];
-          } else {
-            throw error;
-          }
-        }
-      }
-      return data;
-    };
-
-    // Topological sort for dependency order
-    const topologicalSort = (types, deps) => {
-      const visited = new Set();
-      const result = [];
-
-      const visit = (type) => {
-        if (visited.has(type)) return;
-        visited.add(type);
-        const typeDeps = deps[type] || [];
-        for (const dep of typeDeps) {
-          if (types.includes(dep)) {
-            visit(dep);
-          }
-        }
-        result.push(type);
-      };
-
-      for (const type of types) {
-        visit(type);
-      }
-      return result;
-    };
-
-    // Seed TailorDB types via testExecScript
-    const seedViaTestExecScript = async (namespace, typesToSeed, deps) => {
-      const dataDir = join(configDir, "data");
-      const sortedTypes = topologicalSort(typesToSeed, deps);
-      const data = loadSeedData(dataDir, sortedTypes);
-
-      // Skip if no data
-      const typesWithData = sortedTypes.filter((t) => data[t] && data[t].length > 0);
-      if (typesWithData.length === 0) {
-        console.log(styleText("dim", \`  [\${namespace}] No data to seed\`));
-        return { success: true, processed: {} };
-      }
-
-      console.log(styleText("cyan", \`  [\${namespace}] Seeding \${typesWithData.length} types via Kysely batch insert...\`));
-
-      // Bundle seed script
-      const bundled = await bundleSeedScript(namespace, typesWithData);
-
-      // Chunk seed data to fit within gRPC message size limits
-      const chunks = chunkSeedData({
-        data,
-        order: sortedTypes,
-        codeByteSize: new TextEncoder().encode(bundled.bundledCode).length,
-      });
-
-      if (chunks.length === 0) {
-        console.log(styleText("dim", \`  [\${namespace}] No data to seed\`));
-        return { success: true, processed: {} };
-      }
-
-      if (chunks.length > 1) {
-        console.log(styleText("dim", \`    Split into \${chunks.length} chunks\`));
-      }
-
-      const allProcessed = {};
-      let hasError = false;
-      const allErrors = [];
-
-      for (const chunk of chunks) {
-        if (chunks.length > 1) {
-          console.log(styleText("dim", \`    Chunk \${chunk.index + 1}/\${chunk.total}: \${chunk.order.join(", ")}\`));
-        }
-
-        // Execute seed script for this chunk
-        const result = await executeScript({
-          client: operatorClient,
-          workspaceId,
-          name: \`seed-\${namespace}.ts\`,
-          code: bundled.bundledCode,
-          arg: JSON.stringify({ data: chunk.data, order: chunk.order }),
-          invoker: {
-            namespace: authNamespace,
-            machineUserName,
-          },
-        });
-
-        // Parse result and display logs
-        if (result.logs) {
-          for (const line of result.logs.split("\\n").filter(Boolean)) {
-            console.log(styleText("dim", \`    \${line}\`));
-          }
-        }
-
-        if (result.success) {
-          let parsed;
-          try {
-            const parsedResult = JSON.parse(result.result || "{}");
-            parsed = parsedResult && typeof parsedResult === "object" ? parsedResult : {};
-          } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error(styleText("red", \`    ✗ Failed to parse seed result: \${message}\`));
-            hasError = true;
-            allErrors.push(message);
-            continue;
-          }
-
-          const processed = parsed.processed || {};
-          for (const [type, count] of Object.entries(processed)) {
-            allProcessed[type] = (allProcessed[type] || 0) + count;
-            console.log(styleText("green", \`    ✓ \${type}: \${count} rows inserted\`));
-          }
-
-          if (!parsed.success) {
-            const errors = Array.isArray(parsed.errors) ? parsed.errors : [];
-            const errorMessage =
-              errors.length > 0 ? errors.join("\\n        ") : "Seed script reported failure";
-            console.error(styleText("red", \`    ✗ Seed failed:\\n        \${errorMessage}\`));
-            hasError = true;
-            allErrors.push(errorMessage);
-          }
-        } else {
-          console.error(styleText("red", \`    ✗ Seed failed: \${result.error}\`));
-          hasError = true;
-          allErrors.push(result.error);
-        }
-      }
-
-      if (hasError) {
-        return { success: false, error: allErrors.join("\\n") };
-      }
-      return { success: true, processed: allProcessed };
-    };
-
-    ${generateIdpUserSeedFunction(hasIdpUser, idpNamespace)}
-
-    // Main execution
-    try {
-      let allSuccess = true;
-
-      // Determine which namespaces and types to process
-      const namespacesToProcess = hasNamespace
-        ? [values.namespace]
-        : Object.keys(namespaceEntities);
-
-      for (const namespace of namespacesToProcess) {
-        const nsTypes = namespaceEntities[namespace] || [];
-        const nsDeps = namespaceDeps[namespace] || {};
-
-        // Filter types if specific types requested
-        let typesToSeed = entitiesToProcess
-          ? nsTypes.filter((t) => entitiesToProcess.includes(t))
-          : nsTypes;
-
-        if (typesToSeed.length === 0) continue;
-
-        const result = await seedViaTestExecScript(namespace, typesToSeed, nsDeps);
-        if (!result.success) {
-          allSuccess = false;
-        }
-      }
-
-      ${generateIdpUserSeedCall(hasIdpUser)}
-
-      if (allSuccess) {
-        console.log(styleText("green", "\\n✓ Seed data generation completed successfully"));
-      } else {
-        console.error(styleText("red", "\\n✗ Seed data generation completed with errors"));
-        process.exit(1);
-      }
-    } catch (error) {
-      console.error(styleText("red", \`\\n✗ Seed data generation failed: \${error.message}\`));
-      process.exit(1);
-    }
-
-    `;
-}
-/**
-* Factory function to create a Seed generator.
-* Combines Kysely batch insert and lines-db schema generation.
-* @param options - Seed generator options
-* @returns Seed generator
-*/
-function createSeedGenerator(options) {
-	return {
-		id: SeedGeneratorID,
-		description: "Generates seed data files (Kysely batch insert + tailor.idp.Client for _User)",
-		dependencies: ["tailordb"],
-		processType: ({ type, source, namespace }) => {
-			return {
-				typeInfo: processSeedTypeInfo(type, namespace),
-				linesDb: processLinesDb(type, source)
-			};
-		},
-		processTailorDBNamespace: ({ types: types$2 }) => types$2,
-		aggregate: ({ input, configPath }) => {
-			const files = [];
-			const namespaceConfigs = [];
-			for (const nsResult of input.tailordb) {
-				if (!nsResult.types) continue;
-				const outputBaseDir = options.distPath;
-				const types$2 = [];
-				const dependencies = {};
-				for (const [_typeName, metadata] of Object.entries(nsResult.types)) {
-					const { typeInfo, linesDb } = metadata;
-					types$2.push(typeInfo.name);
-					dependencies[typeInfo.name] = typeInfo.dependencies;
-					files.push({
-						path: path$20.join(outputBaseDir, typeInfo.dataFile),
-						content: "",
-						skipIfExists: true
-					});
-					const schemaOutputPath = path$20.join(outputBaseDir, "data", `${linesDb.typeName}.schema.ts`);
-					if (linesDb.pluginSource && linesDb.pluginSource.pluginImportPath) {
-						let originalImportPath;
-						if (linesDb.pluginSource.originalFilePath && linesDb.pluginSource.originalExportName) {
-							const relativePath = path$20.relative(path$20.dirname(schemaOutputPath), linesDb.pluginSource.originalFilePath);
-							originalImportPath = relativePath.replace(/\.ts$/, "").startsWith(".") ? relativePath.replace(/\.ts$/, "") : `./${relativePath.replace(/\.ts$/, "")}`;
-						}
-						const schemaContent = generateLinesDbSchemaFileWithPluginAPI(linesDb, {
-							configImportPath: path$20.relative(path$20.dirname(schemaOutputPath), configPath),
-							originalImportPath
-						});
-						files.push({
-							path: schemaOutputPath,
-							content: schemaContent
-						});
-					} else {
-						const relativePath = path$20.relative(path$20.dirname(schemaOutputPath), linesDb.importPath);
-						const schemaContent = generateLinesDbSchemaFile(linesDb, relativePath.replace(/\.ts$/, "").startsWith(".") ? relativePath.replace(/\.ts$/, "") : `./${relativePath.replace(/\.ts$/, "")}`);
-						files.push({
-							path: schemaOutputPath,
-							content: schemaContent
-						});
-					}
-				}
-				namespaceConfigs.push({
-					namespace: nsResult.namespace,
-					types: types$2,
-					dependencies
-				});
-			}
-			const idpUser = input.auth ? processIdpUser(input.auth) : null;
-			const hasIdpUser = idpUser !== null;
-			if (idpUser) {
-				const outputBaseDir = options.distPath;
-				files.push({
-					path: path$20.join(outputBaseDir, idpUser.dataFile),
-					content: "",
-					skipIfExists: true
-				});
-				files.push({
-					path: path$20.join(outputBaseDir, "data", `${idpUser.name}.schema.ts`),
-					content: generateIdpUserSchemaFile(idpUser.schema.usernameField, idpUser.schema.userTypeName)
-				});
-			}
-			const relativeConfigPath = path$20.relative(options.distPath, configPath);
-			files.push({
-				path: path$20.join(options.distPath, "exec.mjs"),
-				content: generateExecScript(options.machineUserName, relativeConfigPath, namespaceConfigs, hasIdpUser, idpUser?.idpNamespace ?? null)
-			});
-			return { files };
-		}
-	};
-}
-
 //#endregion
 //#region src/cli/mock.ts
 globalThis.tailordb = { Client: class {
@@ -102481,26 +100985,13 @@ globalThis.tailordb = { Client: class {
 
 //#endregion
 //#region src/cli/config-loader.ts
-const GeneratorConfigSchema = z.union([
-	KyselyTypeConfigSchema,
-	SeedConfigSchema,
-	EnumConstantsConfigSchema,
-	FileUtilsConfigSchema,
-	CodeGeneratorSchema
-]).transform((gen) => {
-	if (!Array.isArray(gen)) return gen;
-	const [id, options] = gen;
-	switch (id) {
-		case KyselyGeneratorID: return createKyselyGenerator(options);
-		case SeedGeneratorID: return createSeedGenerator(options);
-		case EnumConstantsGeneratorID: return createEnumConstantsGenerator(options);
-		case FileUtilsGeneratorID: return createFileUtilsGenerator(options);
-		default: {
-			const _exhaustive = id;
-			throw new Error(`Unknown generator ID: ${_exhaustive}`);
-		}
-	}
-}).brand("CodeGenerator");
+const builtinPlugins = new Map([
+	[KyselyGeneratorID, (options) => kyselyTypePlugin(options)],
+	[SeedGeneratorID, (options) => seedPlugin(options)],
+	[EnumConstantsGeneratorID, (options) => enumConstantsPlugin(options)],
+	[FileUtilsGeneratorID, (options) => fileUtilsPlugin(options)]
+]);
+const GeneratorConfigSchema = CodeGeneratorSchema.brand("CodeGenerator");
 const PluginConfigSchema = createPluginConfigSchema();
 /**
 * Load Tailor configuration file and associated generators and plugins.
@@ -102519,16 +101010,27 @@ async function loadConfig(configPath) {
 	for (const value of Object.values(configModule)) if (Array.isArray(value)) {
 		const generatorParsed = value.reduce((acc, item) => {
 			if (!acc.success) return acc;
+			const baseResult = BaseGeneratorConfigSchema.safeParse(item);
+			if (baseResult.success && Array.isArray(baseResult.data)) {
+				const [id, options] = baseResult.data;
+				const pluginFactory = builtinPlugins.get(id);
+				if (pluginFactory) {
+					acc.convertedPlugins.push(pluginFactory(options));
+					return acc;
+				}
+			}
 			const result = GeneratorConfigSchema.safeParse(item);
 			if (result.success) acc.items.push(result.data);
 			else acc.success = false;
 			return acc;
 		}, {
 			success: true,
-			items: []
+			items: [],
+			convertedPlugins: []
 		});
-		if (generatorParsed.success && generatorParsed.items.length > 0) {
+		if (generatorParsed.success && (generatorParsed.items.length > 0 || generatorParsed.convertedPlugins.length > 0)) {
 			allGenerators.push(...generatorParsed.items);
+			allPlugins.push(...generatorParsed.convertedPlugins);
 			continue;
 		}
 		const pluginParsed = value.reduce((acc, item) => {
@@ -103389,5 +101891,5 @@ async function loadApplication(params) {
 }
 
 //#endregion
-export { UserProfileProviderConfig_UserProfileProviderType as $, TailorDBGQLPermission_Action as A, ExecutorJobStatus as B, platformBaseUrl as C, WorkspacePlatformUserRole as D, readPackageJson as E, TailorDBType_PermitAction as F, AuthOAuth2Client_ClientType as G, ExecutorTriggerType as H, PipelineResolver_OperationType as I, AuthSCIMAttribute_Type as J, AuthOAuth2Client_GrantType as K, IdPLang as L, TailorDBGQLPermission_Permit as M, TailorDBType_Permission_Operator as N, WorkflowExecution_Status as O, TailorDBType_Permission_Permit as P, TenantProviderConfig_TenantProviderType as Q, FunctionExecution_Status as R, initOperatorClient as S, userAgent as T, AuthIDPConfig_AuthType as U, ExecutorTargetType as V, AuthInvokerSchema$1 as W, AuthSCIMConfig_AuthorizationType as X, AuthSCIMAttribute_Uniqueness as Y, PATScope as Z, writePlatformConfig as _, hasDependency as a, ApplicationSchemaUpdateAttemptStatus as at, fetchUserInfo as b, OAuth2ClientSchema as c, styles as ct, fetchLatestToken as d, GetApplicationSchemaHealthResponse_ApplicationSchemaHealthStatus as et, loadAccessToken as f, readPlatformConfig as g, loadWorkspaceId as h, loadConfig as i, PageDirection as it, TailorDBGQLPermission_Operator as j, WorkflowJobExecution_Status as k, stringifyFunction as l, symbols as lt, loadOrganizationId as m, generatePluginFilesIfNeeded as n, Condition_Operator as nt, getDistDir as o, Subgraph_ServiceType as ot, loadFolderId as p, AuthSCIMAttribute_Mutability as q, loadApplication as r, FilterSchema as rt, createExecutorService as s, logger as st, defineApplication as t, ConditionSchema as tt, tailorUserMap as u, fetchAll as v, resolveStaticWebsiteUrls as w, initOAuth2Client as x, fetchMachineUserToken as y, FunctionExecution_Type as z };
-//# sourceMappingURL=application-BMDE8KqK.mjs.map
+export { UserProfileProviderConfig_UserProfileProviderType as $, TailorDBGQLPermission_Action as A, ExecutorJobStatus as B, platformBaseUrl as C, WorkspacePlatformUserRole as D, readPackageJson as E, TailorDBType_PermitAction as F, AuthOAuth2Client_ClientType as G, ExecutorTriggerType as H, PipelineResolver_OperationType as I, AuthSCIMAttribute_Type as J, AuthOAuth2Client_GrantType as K, IdPLang as L, TailorDBGQLPermission_Permit as M, TailorDBType_Permission_Operator as N, WorkflowExecution_Status as O, TailorDBType_Permission_Permit as P, TenantProviderConfig_TenantProviderType as Q, FunctionExecution_Status as R, initOperatorClient as S, userAgent as T, AuthIDPConfig_AuthType as U, ExecutorTargetType as V, AuthInvokerSchema$1 as W, AuthSCIMConfig_AuthorizationType as X, AuthSCIMAttribute_Uniqueness as Y, PATScope as Z, writePlatformConfig as _, buildExecutorArgsExpr as a, ApplicationSchemaUpdateAttemptStatus as at, fetchUserInfo as b, createExecutorService as c, styles as ct, fetchLatestToken as d, GetApplicationSchemaHealthResponse_ApplicationSchemaHealthStatus as et, loadAccessToken as f, readPlatformConfig as g, loadWorkspaceId as h, loadConfig as i, PageDirection as it, TailorDBGQLPermission_Operator as j, WorkflowJobExecution_Status as k, OAuth2ClientSchema as l, symbols as lt, loadOrganizationId as m, generatePluginFilesIfNeeded as n, Condition_Operator as nt, buildResolverOperationHookExpr as o, Subgraph_ServiceType as ot, loadFolderId as p, AuthSCIMAttribute_Mutability as q, loadApplication as r, FilterSchema as rt, getDistDir as s, logger as st, defineApplication as t, ConditionSchema as tt, stringifyFunction as u, fetchAll as v, resolveStaticWebsiteUrls as w, initOAuth2Client as x, fetchMachineUserToken as y, FunctionExecution_Type as z };
+//# sourceMappingURL=application-gWUyKuzv.mjs.map