@tailor-platform/sdk 1.11.0 → 1.12.0

package/dist/{update-D0muqqOP.mjs → update-B_W-UQnS.mjs}

@@ -1,5 +1,8 @@
-import { a as OAuth2ClientSchema, c as tailorUserMap, d as styles, f as symbols, i as ExecutorSchema, l as loadFilesWithIgnores, n as WorkflowJobSchema, o as ResolverSchema, r as WorkflowSchema, s as stringifyFunction, t as defineApplication, u as logger } from "./application-BKBo5tGD.mjs";
+import { t as isPluginGeneratedType } from "./types-r-ZratAg.mjs";
+import { t as db } from "./schema-BmKdDzr1.mjs";
+import { a as ExecutorSchema, c as stringifyFunction, d as logger, f as styles, i as createExecutorService, l as tailorUserMap, n as WorkflowJobSchema, o as OAuth2ClientSchema, p as symbols, r as WorkflowSchema, s as ResolverSchema, t as defineApplication, u as loadFilesWithIgnores } from "./application-DnWZVbDO.mjs";
 import { createRequire } from "node:module";
+import { cloneDeep } from "es-toolkit";
 import { arg, defineCommand, runCommand } from "politty";
 import { z } from "zod";
 import * as fs$2 from "node:fs";
@@ -2126,12 +2129,12 @@ async function loadExecutor(executorFilePath) {
 * This function:
 * 1. Creates entry file that extracts operation.body
 * 2. Bundles in a single step with tree-shaking
-* @param config - Executor file loading configuration
-* @param triggerContext - Trigger context for workflow/job transformations
+* @param options - Bundle executor options
 * @returns Promise that resolves when bundling completes
 */
-async function bundleExecutors(config, triggerContext) {
-	const files = loadFilesWithIgnores(config);
+async function bundleExecutors(options) {
+	const { config, triggerContext, additionalFiles = [] } = options;
+	const files = [...loadFilesWithIgnores(config), ...additionalFiles];
 	if (files.length === 0) {
 		logger.warn(`No executor files found for patterns: ${config.files?.join(", ") ?? "(none)"}`);
 		return;
@@ -2680,6 +2683,163 @@ function createGeneratorConfigSchema(builtinGenerators$1) {
 	}).brand("CodeGenerator");
 }
 
+//#endregion
+//#region src/parser/plugin-config/schema.ts
+const unauthenticatedTailorUser$1 = {
+	id: "00000000-0000-0000-0000-000000000000",
+	type: "",
+	workspaceId: "00000000-0000-0000-0000-000000000000",
+	attributes: null,
+	attributeList: []
+};
+const PluginGeneratedTypeSchema = z.object({
+	name: z.string(),
+	fields: z.record(z.string(), z.unknown())
+});
+const PluginGeneratedResolverSchema = z.object({
+	name: z.string(),
+	operation: z.enum(["query", "mutation"]),
+	inputFields: z.record(z.string(), z.unknown()).optional(),
+	outputFields: z.record(z.string(), z.unknown()),
+	body: z.string()
+});
+const PluginTriggerConfigSchema = z.object({
+	kind: z.enum([
+		"recordCreated",
+		"recordUpdated",
+		"recordDeleted",
+		"schedule",
+		"incomingWebhook"
+	]),
+	type: z.string().optional(),
+	schedule: z.string().optional()
+});
+const PluginOperationConfigSchema = z.object({
+	kind: z.enum([
+		"function",
+		"webhook",
+		"graphql",
+		"workflow"
+	]),
+	body: z.string().optional(),
+	url: z.string().optional(),
+	query: z.string().optional()
+});
+const PluginGeneratedExecutorSchema = z.object({
+	name: z.string(),
+	description: z.string().optional(),
+	trigger: PluginTriggerConfigSchema,
+	operation: PluginOperationConfigSchema
+});
+z.object({
+	types: z.array(PluginGeneratedTypeSchema).optional(),
+	resolvers: z.array(PluginGeneratedResolverSchema).optional(),
+	executors: z.array(PluginGeneratedExecutorSchema).optional()
+});
+const CustomPluginSchema = z.object({
+	id: z.string(),
+	description: z.string(),
+	importPath: z.string(),
+	configSchema: z.any().optional(),
+	pluginConfigSchema: z.any().optional(),
+	pluginConfig: z.any().optional(),
+	process: z.any().optional(),
+	processNamespace: z.any().optional()
+}).superRefine((plugin, ctx) => {
+	if (plugin.process && !plugin.configSchema) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "process requires configSchema to be defined.",
+		path: ["configSchema"]
+	});
+}).passthrough();
+const CustomPluginTupleSchema = z.tuple([CustomPluginSchema, z.unknown()]);
+/**
+* Type guard to check if a value is a PluginBase object
+* @param value - Value to check
+* @returns True if value is a PluginBase object
+*/
+function isPluginBase(value) {
+	return CustomPluginSchema.safeParse(value).success;
+}
+function normalizePluginConfigSchema(schema) {
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [schema];
+	while (stack.length > 0) {
+		const field = stack.pop();
+		if (!field || seen.has(field)) continue;
+		seen.add(field);
+		const requiredExplicit = field._metadata.requiredExplicit === true;
+		field._metadata.required = requiredExplicit;
+		for (const nestedField of Object.values(field.fields)) stack.push(nestedField);
+	}
+	return schema;
+}
+function clonePluginConfigSchema(schema) {
+	return cloneDeep(schema);
+}
+function normalizePluginBase(plugin) {
+	let normalized = plugin;
+	if (normalized.configSchema) {
+		const clonedConfigSchema = clonePluginConfigSchema(normalized.configSchema);
+		normalizePluginConfigSchema(clonedConfigSchema);
+		normalized = {
+			...normalized,
+			configSchema: clonedConfigSchema
+		};
+	}
+	if (normalized.pluginConfigSchema) {
+		const pluginConfigSchema = clonePluginConfigSchema(normalized.pluginConfigSchema);
+		normalizePluginConfigSchema(pluginConfigSchema);
+		normalized = {
+			...normalized,
+			pluginConfigSchema
+		};
+		if (normalized.pluginConfig !== void 0) {
+			const validationErrors = validatePluginConfig$1(normalized.pluginConfig, pluginConfigSchema);
+			if (validationErrors.length > 0) {
+				const errorDetails = validationErrors.map((e) => e.field ? `${e.field}: ${e.message}` : e.message).join("; ");
+				throw new Error(`Invalid pluginConfig for plugin "${normalized.id}": ${errorDetails}`);
+			}
+		}
+	}
+	return normalized;
+}
+/**
+* Validate plugin config against its schema
+* @param config - The config object to validate
+* @param schema - The schema defining expected fields
+* @returns Array of validation errors (empty if valid)
+*/
+function validatePluginConfig$1(config, schema) {
+	const result = schema.parse({
+		value: config,
+		data: config,
+		user: unauthenticatedTailorUser$1
+	});
+	if ("issues" in result && result.issues) return result.issues.map((issue) => ({
+		field: Array.isArray(issue.path) ? issue.path.join(".") : "",
+		message: issue.message
+	}));
+	return [];
+}
+/**
+* Creates a PluginConfigSchema for custom plugins
+* @returns Plugin config schema that validates and transforms PluginBase instances
+*/
+function createPluginConfigSchema() {
+	return z.union([CustomPluginSchema, CustomPluginTupleSchema]).transform((plugin) => {
+		if (Array.isArray(plugin)) {
+			const [first, options] = plugin;
+			if (isPluginBase(first)) return normalizePluginBase({
+				...first,
+				pluginConfig: options
+			});
+			throw new Error(`Invalid plugin configuration: expected PluginBase object`);
+		}
+		return normalizePluginBase(plugin);
+	}).brand("Plugin");
+}
+
 //#endregion
 //#region src/cli/generator/types.ts
 /**
@@ -3118,28 +3278,22 @@ function generateUnifiedKyselyTypes(namespaceData) {
 		Timestamp: false,
 		Serial: false
 	});
-	const utilityTypeDeclarations = [];
-	if (globalUsedUtilityTypes.Timestamp) utilityTypeDeclarations.push(`type Timestamp = ColumnType<Date, Date | string, Date | string>;`);
-	utilityTypeDeclarations.push(ml`
-      type Generated<T> = T extends ColumnType<infer S, infer I, infer U>
-        ? ColumnType<S, I | undefined, U>
-        : ColumnType<T, T | undefined, T>;
-    `);
-	if (globalUsedUtilityTypes.Serial) utilityTypeDeclarations.push(`type Serial<T = string | number> = ColumnType<T, never, never>;`);
+	const utilityTypeImports = ["type Generated"];
+	if (globalUsedUtilityTypes.Timestamp) utilityTypeImports.push("type Timestamp");
+	if (globalUsedUtilityTypes.Serial) utilityTypeImports.push("type Serial");
 	return [
 		ml`
     import {
-      type ColumnType,
-      Kysely,
-      type KyselyConfig,
-      type Transaction as KyselyTransaction,
-      type Insertable as KyselyInsertable,
-      type Selectable as KyselySelectable,
-      type Updateable as KyselyUpdateable,
-    } from "kysely";
-    import { TailordbDialect } from "@tailor-platform/function-kysely-tailordb";
-
-    ${utilityTypeDeclarations.join("\n")}
+      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 }) => {
 			return `  "${namespace}": {\n${types.map((type) => {
@@ -3147,44 +3301,20 @@ function generateUnifiedKyselyTypes(namespaceData) {
 			}).join("\n\n")}\n  }`;
 		}).join(",\n")}\n}`,
 		ml`
-    export function getDB<const N extends keyof Namespace>(
-      namespace: N,
-      kyselyConfig?: Omit<KyselyConfig, "dialect">,
-    ): Kysely<Namespace[N]> {
-      const client = new tailordb.Client({ namespace });
-      return new Kysely<Namespace[N]>({
-        dialect: new TailordbDialect(client),
-        ...kyselyConfig,
-      });
-    }
+    export const getDB = createGetDB<Namespace>();
 
-    export type DB<N extends keyof Namespace = keyof Namespace> = ReturnType<typeof getDB<N>>;
+    export type DB<N extends keyof Namespace = keyof Namespace> = NamespaceDB<Namespace, N>;
   `,
 		ml`
     export type Transaction<K extends keyof Namespace | DB = keyof Namespace> =
-      K extends DB<infer N>
-        ? KyselyTransaction<Namespace[N]>
-        : K extends keyof Namespace
-          ? KyselyTransaction<Namespace[K]>
-          : never;
-
-    type TableName = {
-      [N in keyof Namespace]: keyof Namespace[N];
-    }[keyof Namespace];
-    export type Table<T extends TableName> = {
-      [N in keyof Namespace]: T extends keyof Namespace[N] ? Namespace[N][T]
-        : never;
-    }[keyof Namespace];
-
-    export type Insertable<T extends keyof Namespace[keyof Namespace]> = KyselyInsertable<
-      Table<T>
-    >;
-    export type Selectable<T extends keyof Namespace[keyof Namespace]> = KyselySelectable<
-      Table<T>
-    >;
-    export type Updateable<T extends keyof Namespace[keyof Namespace]> = KyselyUpdateable<
-      Table<T>
-    >;
+      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";
 }
@@ -3237,6 +3367,32 @@ function createKyselyGenerator(options) {
 	};
 }
 
+//#endregion
+//#region src/cli/utils/plugin-import.ts
+/**
+* Collect base directories for resolving plugin import paths.
+* @param configPath - Path to tailor.config.ts
+* @returns Ordered list of base directories
+*/
+function getPluginImportBaseDirs(configPath) {
+	if (configPath) return [path.dirname(configPath)];
+	return [process.cwd()];
+}
+/**
+* Resolve a relative plugin import path against candidate base directories.
+* @param pluginImportPath - Relative plugin import path
+* @param baseDirs - Candidate base directories
+* @returns Absolute path if found, otherwise null
+*/
+function resolveRelativePluginImportPath(pluginImportPath, baseDirs) {
+	if (!pluginImportPath.startsWith(".")) return null;
+	for (const baseDir of baseDirs) {
+		const absolutePath = path.resolve(baseDir, pluginImportPath);
+		if (fs$2.existsSync(absolutePath)) return absolutePath;
+	}
+	return null;
+}
+
 //#endregion
 //#region src/cli/generator/builtin/seed/idp-user-processor.ts
 /**
@@ -3314,7 +3470,45 @@ function generateIdpUserSchemaFile(usernameField, userTypeName) {
 * @returns Generated lines-db metadata
 */
 function processLinesDb(type, source) {
-	if (!source.filePath || !source.exportName) throw new Error(`Missing source info for type ${type.name}`);
+	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 = [];
@@ -3341,29 +3535,19 @@ function processLinesDb(type, source) {
 		}
 	});
 	return {
-		typeName: type.name,
-		exportName: source.exportName,
-		importPath: source.filePath,
 		optionalFields,
 		omitFields,
-		foreignKeys,
-		indexes
+		indexes,
+		foreignKeys
 	};
 }
 /**
-* Generates the schema file content for lines-db
-* @param metadata - lines-db metadata
-* @param importPath - Import path for the TailorDB type
-* @returns Schema file contents
+* Generate schema options code for lines-db
+* @param foreignKeys - Foreign key definitions
+* @param indexes - Index definitions
+* @returns Schema options code string
 */
-function generateLinesDbSchemaFile(metadata, importPath) {
-	const { exportName, optionalFields, omitFields, foreignKeys, indexes } = metadata;
-	const schemaTypeCode = ml`
-    const schemaType = t.object({
-      ...${exportName}.pickFields(${JSON.stringify(optionalFields)}, { optional: true }),
-      ...${exportName}.omitFields(${JSON.stringify([...optionalFields, ...omitFields])}),
-    });
-    `;
+function generateSchemaOptions(foreignKeys, indexes) {
 	const schemaOptions = [];
 	if (foreignKeys.length > 0) {
 		schemaOptions.push(`foreignKeys: [`);
@@ -3379,22 +3563,92 @@ function generateLinesDbSchemaFile(metadata, importPath) {
 		});
 		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 { pluginImportPath, 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 { t } from "@tailor-platform/sdk";
+    import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
+    import { defineSchema } from "@toiroakr/lines-db";
+    import { getGeneratedType } from "${pluginImportPath}";
+    import { ${pluginSource.originalExportName} } from "${originalImportPath}";
+
+    const ${exportName} = getGeneratedType(${pluginSource.originalExportName}, "${pluginSource.generatedTypeKind}");
+
     ${schemaTypeCode}
 
     const hook = createTailorDBHook(${exportName});
 
     export const schema = defineSchema(
-      createStandardSchema(schemaType, hook),${schemaOptions.length > 0 ? [
-		"\n  {",
-		...schemaOptions.map((option) => `    ${option}`),
-		"  }"
-	].join("\n") : ""}
+      createStandardSchema(schemaType, hook),${schemaOptionsCode}
+    );
+
+    `;
+	if (!pluginSource.generatedTypeKind) throw new Error(`Namespace plugin "${pluginSource.pluginId}" must provide generatedTypeKind for type "${typeName}"`);
+	return ml`
+    import { t } from "@tailor-platform/sdk";
+    import { createTailorDBHook, createStandardSchema } from "@tailor-platform/sdk/test";
+    import { defineSchema } from "@toiroakr/lines-db";
+    import { getGeneratedType } from "${pluginImportPath}";
+
+    const ${exportName} = getGeneratedType(null, "${pluginSource.generatedTypeKind}");
+
+    ${schemaTypeCode}
+
+    const hook = createTailorDBHook(${exportName});
+
+    export const schema = defineSchema(
+      createStandardSchema(schemaType, hook),${schemaOptionsCode}
     );
 
     `;
@@ -3512,6 +3766,7 @@ function generateExecScript(machineUserName, relativeConfigPath, namespaceConfig
       getMachineUserToken,
       truncate,
       bundleSeedScript,
+      chunkSeedData,
       executeScript,
       initOperatorClient,
       loadAccessToken,
@@ -3782,55 +4037,89 @@ ${namespaceConfigs.map(({ namespace, dependencies }) => {
       // Bundle seed script
       const bundled = await bundleSeedScript(namespace, typesWithData);
 
-      // Execute seed script
-      const result = await executeScript({
-        client: operatorClient,
-        workspaceId,
-        name: \`seed-\${namespace}.ts\`,
-        code: bundled.bundledCode,
-        arg: JSON.stringify({ data, order: sortedTypes }),
-        invoker: {
-          namespace: authNamespace,
-          machineUserName: "${machineUserName}",
-        },
+      // Chunk seed data to fit within gRPC message size limits
+      const chunks = chunkSeedData({
+        data,
+        order: sortedTypes,
+        codeByteSize: new TextEncoder().encode(bundled.bundledCode).length,
       });
 
-      // Parse result and display logs
-      if (result.logs) {
-        for (const line of result.logs.split("\\n").filter(Boolean)) {
-          console.log(styleText("dim", \`    \${line}\`));
-        }
+      if (chunks.length === 0) {
+        console.log(styleText("dim", \`  [\${namespace}] No data to seed\`));
+        return { success: true, processed: {} };
       }
 
-      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}\`));
-          return { success: false, error: message };
+      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(", ")}\`));
         }
 
-        const processed = parsed.processed || {};
-        for (const [type, count] of Object.entries(processed)) {
-          console.log(styleText("green", \`    ✓ \${type}: \${count} rows inserted\`));
+        // 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: "${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 (!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: \${errorMessage}\`));
-          return { success: false, error: errorMessage };
+        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: \${errorMessage}\`));
+            hasError = true;
+            allErrors.push(errorMessage);
+          }
+        } else {
+          console.error(styleText("red", \`    ✗ Seed failed: \${result.error}\`));
+          hasError = true;
+          allErrors.push(result.error);
         }
+      }
 
-        return { success: true, processed };
-      } else {
-        console.error(styleText("red", \`    ✗ Seed failed: \${result.error}\`));
-        return { success: false, error: result.error };
+      if (hasError) {
+        return { success: false, error: allErrors.join("\\n") };
       }
+      return { success: true, processed: allProcessed };
     };
 
     ${generateIdpUserSeedFunction(hasIdpUser)}
@@ -3896,6 +4185,7 @@ function createSeedGenerator(options) {
 		processTailorDBNamespace: ({ types }) => types,
 		aggregate: ({ input, configPath }) => {
 			const files = [];
+			const pluginImportBaseDirs = getPluginImportBaseDirs(configPath);
 			const namespaceConfigs = [];
 			for (const nsResult of input.tailordb) {
 				if (!nsResult.types) continue;
@@ -3912,12 +4202,34 @@ function createSeedGenerator(options) {
 						skipIfExists: true
 					});
 					const schemaOutputPath = path.join(outputBaseDir, "data", `${linesDb.typeName}.schema.ts`);
-					const importPath = path.relative(path.dirname(schemaOutputPath), linesDb.importPath);
-					const normalizedImportPath = importPath.replace(/\.ts$/, "").startsWith(".") ? importPath.replace(/\.ts$/, "") : `./${importPath.replace(/\.ts$/, "")}`;
-					files.push({
-						path: schemaOutputPath,
-						content: generateLinesDbSchemaFile(linesDb, normalizedImportPath)
-					});
+					if (linesDb.pluginSource && linesDb.pluginSource.pluginImportPath) {
+						let originalImportPath;
+						if (linesDb.pluginSource.originalFilePath && linesDb.pluginSource.originalExportName) {
+							const relativePath = path.relative(path.dirname(schemaOutputPath), linesDb.pluginSource.originalFilePath);
+							originalImportPath = relativePath.replace(/\.ts$/, "").startsWith(".") ? relativePath.replace(/\.ts$/, "") : `./${relativePath.replace(/\.ts$/, "")}`;
+						}
+						let pluginImportPath = linesDb.pluginSource.pluginImportPath;
+						if (pluginImportPath.startsWith("./") || pluginImportPath.startsWith("../")) {
+							const resolvedPluginPath = resolveRelativePluginImportPath(pluginImportPath, pluginImportBaseDirs) ?? path.resolve(pluginImportBaseDirs[0] ?? process.cwd(), pluginImportPath);
+							const relativePluginPath = path.relative(path.dirname(schemaOutputPath), resolvedPluginPath);
+							pluginImportPath = relativePluginPath.startsWith(".") ? relativePluginPath : `./${relativePluginPath}`;
+						}
+						const schemaContent = generateLinesDbSchemaFileWithPluginAPI(linesDb, {
+							pluginImportPath,
+							originalImportPath
+						});
+						files.push({
+							path: schemaOutputPath,
+							content: schemaContent
+						});
+					} else {
+						const relativePath = path.relative(path.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,
@@ -3971,10 +4283,11 @@ const builtinGenerators = new Map([
 	[FileUtilsGeneratorID, (options) => createFileUtilsGenerator(options)]
 ]);
 const GeneratorConfigSchema = createGeneratorConfigSchema(builtinGenerators);
+const PluginConfigSchema = createPluginConfigSchema();
 /**
-* Load Tailor configuration file and associated generators.
+* Load Tailor configuration file and associated generators and plugins.
 * @param configPath - Optional explicit config path
-* @returns Loaded config and generators
+* @returns Loaded config, generators, plugins, and config path
 */
 async function loadConfig(configPath) {
 	const foundPath = loadConfigPath(configPath);
@@ -3984,8 +4297,9 @@ async function loadConfig(configPath) {
 	const configModule = await import(pathToFileURL(resolvedPath).href);
 	if (!configModule || !configModule.default) throw new Error("Invalid Tailor config module: default export not found");
 	const allGenerators = [];
+	const allPlugins = [];
 	for (const value of Object.values(configModule)) if (Array.isArray(value)) {
-		const parsed = value.reduce((acc, item) => {
+		const generatorParsed = value.reduce((acc, item) => {
 			if (!acc.success) return acc;
 			const result = GeneratorConfigSchema.safeParse(item);
 			if (result.success) acc.items.push(result.data);
@@ -3995,16 +4309,532 @@ async function loadConfig(configPath) {
 			success: true,
 			items: []
 		});
-		allGenerators.push(...parsed.items);
+		if (generatorParsed.success && generatorParsed.items.length > 0) {
+			allGenerators.push(...generatorParsed.items);
+			continue;
+		}
+		const pluginParsed = value.reduce((acc, item) => {
+			if (!acc.success) return acc;
+			const result = PluginConfigSchema.safeParse(item);
+			if (result.success) acc.items.push(result.data);
+			else acc.success = false;
+			return acc;
+		}, {
+			success: true,
+			items: []
+		});
+		if (pluginParsed.success && pluginParsed.items.length > 0) allPlugins.push(...pluginParsed.items);
 	}
 	return {
 		config: {
 			...configModule.default,
 			path: resolvedPath
 		},
-		generators: allGenerators
+		generators: allGenerators,
+		plugins: allPlugins
+	};
+}
+
+//#endregion
+//#region src/parser/plugin-config/types.ts
+/**
+* Type guard to check if executor uses the new dynamic import format.
+* @param executor - Executor definition to check
+* @returns True if executor uses dynamic import format
+*/
+function isPluginExecutorWithFile(executor) {
+	return "resolve" in executor && "context" in executor;
+}
+
+//#endregion
+//#region src/cli/generator/plugin-executor-generator.ts
+/**
+* Plugin Executor Generator
+*
+* Generates TypeScript files for plugin-generated executors.
+* Supports both legacy format (inline trigger/operation) and new format (executorFile/context).
+*/
+/**
+* Generate TypeScript files for plugin-generated executors.
+* These files will be processed by the standard executor bundler.
+* @param executors - Array of plugin executor information
+* @param outputDir - Base output directory (e.g., .tailor-sdk)
+* @param typeGenerationResult - Result from plugin type generation (for import resolution)
+* @param sourceTypeInfoMap - Map of source type names to their source info
+* @param configPath - Path to tailor.config.ts (used for resolving plugin import paths)
+* @returns Array of generated file paths
+*/
+function generatePluginExecutorFiles(executors, outputDir, typeGenerationResult, sourceTypeInfoMap, configPath) {
+	if (executors.length === 0) return [];
+	const generatedFiles = [];
+	const baseDirs = getPluginImportBaseDirs(configPath);
+	for (const info of executors) {
+		const filePath = generateSingleExecutorFile(info, outputDir, typeGenerationResult, sourceTypeInfoMap, baseDirs);
+		generatedFiles.push(filePath);
+		const relativePath = path.relative(process.cwd(), filePath);
+		logger.log(`  Plugin Executor File: ${styles.success(relativePath)} from plugin ${styles.info(info.pluginId)}`);
+	}
+	return generatedFiles;
+}
+/**
+* Generate a single executor file.
+* @param info - Plugin executor metadata and definition
+* @param outputDir - Base output directory (e.g., .tailor-sdk)
+* @param typeGenerationResult - Result from plugin type generation
+* @param sourceTypeInfoMap - Map of source type names to their source info
+* @param baseDirs - Base directories for resolving plugin import paths
+* @returns Absolute path to the generated file
+*/
+function generateSingleExecutorFile(info, outputDir, typeGenerationResult, sourceTypeInfoMap, baseDirs = []) {
+	const pluginDir = sanitizePluginId$1(info.pluginId);
+	const executorOutputDir = path.join(outputDir, pluginDir, "executors");
+	fs$2.mkdirSync(executorOutputDir, { recursive: true });
+	const fileName = sanitizeExecutorFileName(info.executor.name);
+	const filePath = path.join(executorOutputDir, `${fileName}.ts`);
+	let content;
+	if (isPluginExecutorWithFile(info.executor)) content = generateExecutorFileContentNew(info, info.executor, outputDir, typeGenerationResult, sourceTypeInfoMap, baseDirs);
+	else content = generateExecutorFileContentLegacy(info.executor);
+	fs$2.writeFileSync(filePath, content);
+	return filePath;
+}
+/**
+* Generate TypeScript file content for new format executor (dynamic import).
+* Uses the executor's resolve function to dynamically import the module.
+* @param info - Plugin executor information
+* @param executor - Executor definition with resolve
+* @param outputDir - Base output directory
+* @param typeGenerationResult - Result from plugin type generation
+* @param sourceTypeInfoMap - Map of source type names to their source info
+* @param baseDirs - Base directories for resolving plugin import paths
+* @returns TypeScript source code for executor file
+*/
+function generateExecutorFileContentNew(info, executor, outputDir, typeGenerationResult, sourceTypeInfoMap, baseDirs = []) {
+	const { resolve, context } = executor;
+	const pluginDir = sanitizePluginId$1(info.pluginId);
+	const executorOutputDir = path.join(outputDir, pluginDir, "executors");
+	const executorImportPath = resolveExecutorImportPath(resolve, info.pluginImportPath, executorOutputDir, baseDirs);
+	const typeImports = collectTypeImports(context, outputDir, info.pluginId, typeGenerationResult, sourceTypeInfoMap);
+	const imports = [];
+	for (const [, importInfo] of typeImports) imports.push(`import { ${importInfo.variableName} } from "${importInfo.importPath}";`);
+	const contextCode = generateContextCode(context, typeImports);
+	return ml`
+    /**
+     * Auto-generated executor by plugin: ${info.pluginId}
+     * DO NOT EDIT - This file is generated by @tailor-platform/sdk
+     */
+    ${imports.join("\n")}
+
+    const { default: executorFactory } = await import(${JSON.stringify(executorImportPath)});
+    if (typeof executorFactory !== "function") {
+      throw new Error(
+        "Plugin executor module must export a default function created by withPluginContext().",
+      );
+    }
+    export default executorFactory(${contextCode});
+  `;
+}
+/**
+* Collect type imports needed for context.
+* @param context - Executor context values from plugin
+* @param outputDir - Base output directory for generated files
+* @param pluginId - Plugin identifier used for output paths
+* @param typeGenerationResult - Result from plugin type generation
+* @param sourceTypeInfoMap - Map of source type names to their source info
+* @returns Map of context keys to their import information
+*/
+function collectTypeImports(context, outputDir, pluginId, typeGenerationResult, sourceTypeInfoMap) {
+	const typeImports = /* @__PURE__ */ new Map();
+	const pluginDir = sanitizePluginId$1(pluginId);
+	const executorDir = path.join(outputDir, pluginDir, "executors");
+	for (const [key, value] of Object.entries(context)) if (isTypeObject(value)) {
+		const typeName = value.name;
+		const sourceInfo = sourceTypeInfoMap?.get(typeName);
+		const variableName = sourceInfo?.exportName ?? toCamelCase$1(typeName);
+		let importPath;
+		let isGeneratedType = false;
+		if (typeGenerationResult?.typeFilePaths.has(typeName)) {
+			const typeFilePath = typeGenerationResult.typeFilePaths.get(typeName);
+			const absoluteTypePath = path.join(outputDir, typeFilePath);
+			importPath = path.relative(executorDir, absoluteTypePath).replace(/\.ts$/, "");
+			if (!importPath.startsWith(".")) importPath = `./${importPath}`;
+			isGeneratedType = true;
+		} else if (sourceInfo) {
+			const sourceFilePath = sourceInfo.filePath;
+			importPath = path.relative(executorDir, sourceFilePath).replace(/\.ts$/, "");
+			if (!importPath.startsWith(".")) importPath = `./${importPath}`;
+		} else importPath = `../../../../tailordb/${toKebabCase$1(typeName)}`;
+		typeImports.set(key, {
+			variableName,
+			importPath,
+			isGeneratedType
+		});
+	}
+	return typeImports;
+}
+/**
+* Generate TypeScript code for context object.
+* @param context - Executor context values from plugin
+* @param typeImports - Resolved type import information for context keys
+* @returns TypeScript object literal code
+*/
+function generateContextCode(context, typeImports) {
+	const entries = [];
+	for (const [key, value] of Object.entries(context)) if (isTypeObject(value)) {
+		const importInfo = typeImports.get(key);
+		if (importInfo) entries.push(`  ${key}: ${importInfo.variableName}`);
+	} else if (value !== void 0) entries.push(`  ${key}: ${JSON.stringify(value)}`);
+	return `{\n${entries.join(",\n")},\n}`;
+}
+/**
+* Check if a value is a TailorDB type object.
+* @param value - Value to inspect
+* @returns True if value is a type object with name and fields
+*/
+function isTypeObject(value) {
+	return typeof value === "object" && value !== null && "name" in value && "fields" in value && typeof value.name === "string";
+}
+/**
+* Generate TypeScript file content for legacy format executor (trigger/operation).
+* @param executor - Legacy executor definition
+* @returns TypeScript source code for executor file
+*/
+function generateExecutorFileContentLegacy(executor) {
+	const triggerCode = generateTriggerCode(executor.trigger);
+	const operationCode = generateOperationCode(executor.operation);
+	const injectDeclarations = generateInjectDeclarations(executor.operation.kind === "function" ? executor.operation.inject : void 0);
+	const descriptionLine = executor.description ? `\n  description: ${JSON.stringify(executor.description)},` : "";
+	return ml`
+    /**
+     * Auto-generated executor by plugin
+     * DO NOT EDIT - This file is generated by @tailor-platform/sdk
+     */
+    import { createExecutor } from "@tailor-platform/sdk";
+    ${injectDeclarations}
+    export default createExecutor({
+      name: ${JSON.stringify(executor.name)},${descriptionLine}
+      trigger: ${triggerCode},
+      operation: ${operationCode},
+    });
+  `;
+}
+/**
+* Generate const declarations for injected variables.
+* @param inject - Map of injected values keyed by variable name
+* @returns TypeScript const declarations or empty string
+*/
+function generateInjectDeclarations(inject) {
+	if (!inject || Object.keys(inject).length === 0) return "";
+	return `\n// Injected variables from plugin\n${Object.entries(inject).map(([name, value]) => `const ${name} = ${JSON.stringify(value)};`).join("\n")}\n`;
+}
+/**
+* Generate TypeScript code for trigger configuration.
+* @param trigger - Trigger configuration for executor
+* @returns TypeScript code for trigger object
+*/
+function generateTriggerCode(trigger) {
+	switch (trigger.kind) {
+		case "recordCreated":
+		case "recordUpdated":
+		case "recordDeleted": return `{
+    kind: ${JSON.stringify(trigger.kind)},
+    typeName: ${JSON.stringify(trigger.typeName)},
+  }`;
+		case "schedule": return `{
+    kind: "schedule",
+    cron: ${JSON.stringify(trigger.cron)},
+    timezone: ${JSON.stringify(trigger.timezone ?? "UTC")},
+  }`;
+		case "incomingWebhook": return `{
+    kind: "incomingWebhook",
+  }`;
+		default: throw new Error(`Unknown trigger kind: ${trigger.kind}`);
+	}
+}
+/**
+* Generate TypeScript code for operation configuration.
+* @param operation - Operation configuration for executor
+* @returns TypeScript code for operation object
+*/
+function generateOperationCode(operation) {
+	switch (operation.kind) {
+		case "graphql": {
+			const appNameLine = operation.appName ? `\n    appName: ${JSON.stringify(operation.appName)},` : "";
+			const variablesLine = operation.variables ? `\n    variables: ${operation.variables},` : "";
+			return `{
+    kind: "graphql",
+    query: \`${escapeTemplateLiteral(operation.query)}\`,${appNameLine}${variablesLine}
+  }`;
+		}
+		case "function": return `{
+    kind: "function",
+    body: ${operation.body},
+  }`;
+		case "webhook": return `{
+    kind: "webhook",
+    url: () => ${JSON.stringify(operation.url)},
+  }`;
+		case "workflow": return `{
+    kind: "workflow",
+    workflowName: ${JSON.stringify(operation.workflowName)},
+  }`;
+		default: throw new Error(`Unknown operation kind: ${operation.kind}`);
+	}
+}
+/**
+* Escape special characters in template literal content.
+* @param str - Raw template literal content
+* @returns Escaped string safe for template literals
+*/
+function escapeTemplateLiteral(str) {
+	return str.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+}
+const require$1 = createRequire(import.meta.url);
+/**
+* Resolve the import path for a plugin executor module.
+* @param resolve - Executor resolve function
+* @param pluginImportPath - Plugin's import path
+* @param executorOutputDir - Directory where the generated executor will be written
+* @param baseDirs - Base directories for resolving plugin import paths
+* @returns Import path string for the executor module
+*/
+function resolveExecutorImportPath(resolve, pluginImportPath, executorOutputDir, baseDirs) {
+	const specifier = extractDynamicImportSpecifier(resolve);
+	if (!specifier.startsWith(".")) return specifier;
+	const pluginBaseDir = resolvePluginBaseDir(pluginImportPath, baseDirs);
+	if (!pluginBaseDir) throw new Error(`Unable to resolve plugin import base for "${pluginImportPath}". Tried base dirs: ${baseDirs.join(", ") || "(none)"}. Use an absolute import specifier in resolve(), or ensure the plugin path is resolvable.`);
+	const absolutePath = path.resolve(pluginBaseDir, specifier);
+	let relativePath = path.relative(executorOutputDir, absolutePath).replace(/\\/g, "/");
+	relativePath = stripSourceExtension(relativePath);
+	if (!relativePath.startsWith(".")) relativePath = `./${relativePath}`;
+	return relativePath;
+}
+/**
+* Extract the dynamic import specifier from a resolve function.
+* @param resolve - Executor resolve function
+* @returns The module specifier string
+*/
+function extractDynamicImportSpecifier(resolve) {
+	const match = resolve.toString().match(/import\s*\(\s*["']([^"']+)["']\s*\)/);
+	if (!match) throw new Error(`resolve() must return a dynamic import, e.g. \`async () => await import("./executors/on-create")\`.`);
+	return match[1];
+}
+/**
+* Resolve plugin base directory for relative imports.
+* @param pluginImportPath - Plugin import path
+* @param baseDirs - Base directories for resolving plugin import paths
+* @returns Directory path or null if not resolvable
+*/
+function resolvePluginBaseDir(pluginImportPath, baseDirs) {
+	if (pluginImportPath.startsWith(".")) {
+		const resolvedPath = resolveRelativePluginImportPath(pluginImportPath, baseDirs) ?? path.resolve(baseDirs[0] ?? process.cwd(), pluginImportPath);
+		if (fs$2.existsSync(resolvedPath)) return fs$2.statSync(resolvedPath).isDirectory() ? resolvedPath : path.dirname(resolvedPath);
+		return path.extname(resolvedPath) ? path.dirname(resolvedPath) : resolvedPath;
+	}
+	for (const baseDir of baseDirs) try {
+		const resolved = require$1.resolve(pluginImportPath, { paths: [baseDir] });
+		return path.dirname(resolved);
+	} catch {
+		continue;
+	}
+	return null;
+}
+/**
+* Strip TypeScript source extensions from import paths.
+* @param importPath - Path to normalize
+* @returns Path without .ts/.tsx extension
+*/
+function stripSourceExtension(importPath) {
+	return importPath.replace(/\.(ts|tsx)$/, "");
+}
+/**
+* Convert plugin ID to safe directory name.
+* @param pluginId - Plugin identifier (e.g., "@scope/name")
+* @returns Safe directory name
+*/
+function sanitizePluginId$1(pluginId) {
+	return pluginId.replace(/^@/, "").replace(/\//g, "-");
+}
+/**
+* Convert executor name to safe filename.
+* @param executorName - Executor name
+* @returns Safe filename without extension
+*/
+function sanitizeExecutorFileName(executorName) {
+	const sanitized = path.basename(executorName).replace(/\.[^/.]+$/, "").replace(/[^a-zA-Z0-9_-]/g, "-");
+	if (!sanitized) throw new Error(`Invalid executor name: "${executorName}"`);
+	return sanitized;
+}
+/**
+* Convert string to camelCase.
+* @param str - Input string to convert
+* @returns camelCase string
+*/
+function toCamelCase$1(str) {
+	const result = str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "");
+	return result.charAt(0).toLowerCase() + result.slice(1);
+}
+/**
+* Convert string to kebab-case.
+* @param str - Input string to convert
+* @returns kebab-case string
+*/
+function toKebabCase$1(str) {
+	return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+
+//#endregion
+//#region src/cli/generator/plugin-type-generator.ts
+/**
+* Plugin Type Generator
+*
+* Generates TypeScript files for plugin-generated types (TailorDB types).
+* These files can be imported by plugin executors to reference generated types.
+*/
+/**
+* Generate TypeScript files for plugin-generated types.
+* These files export the type definition and can be imported by executor files.
+* @param types - Array of plugin type information
+* @param outputDir - Base output directory (e.g., .tailor-sdk)
+* @returns Generation result with file paths
+*/
+function generatePluginTypeFiles(types, outputDir) {
+	const typeFilePaths = /* @__PURE__ */ new Map();
+	const generatedFiles = [];
+	if (types.length === 0) return {
+		typeFilePaths,
+		generatedFiles
+	};
+	const seenTypeNames = /* @__PURE__ */ new Map();
+	for (const info of types) {
+		const existing = seenTypeNames.get(info.type.name);
+		if (existing) throw new Error(`Duplicate plugin-generated type name "${info.type.name}" detected. First: plugin "${existing.pluginId}" (kind: "${existing.kind}", source type: "${existing.sourceTypeName}"), Second: plugin "${info.pluginId}" (kind: "${info.kind}", source type: "${info.sourceTypeName}"). Plugin-generated type names must be unique.`);
+		seenTypeNames.set(info.type.name, info);
+		const pluginDir = sanitizePluginId(info.pluginId);
+		const typeOutputDir = path.join(outputDir, pluginDir, "types");
+		fs$2.mkdirSync(typeOutputDir, { recursive: true });
+		const fileName = `${toKebabCase(info.type.name)}.ts`;
+		const filePath = path.join(typeOutputDir, fileName);
+		const content = generateTypeFileContent(info);
+		fs$2.writeFileSync(filePath, content);
+		generatedFiles.push(filePath);
+		const relativePath = path.relative(outputDir, filePath);
+		typeFilePaths.set(info.type.name, relativePath);
+		const displayPath = path.relative(process.cwd(), filePath);
+		logger.log(`  Plugin Type File: ${styles.success(displayPath)} (${styles.dim(info.kind)}) from plugin ${styles.info(info.pluginId)}`);
+	}
+	return {
+		typeFilePaths,
+		generatedFiles
 	};
 }
+/**
+* Generate TypeScript file content for a single type.
+* @param info - Plugin type information
+* @returns TypeScript source code
+*/
+function generateTypeFileContent(info) {
+	const { type, pluginId, sourceTypeName, kind } = info;
+	const variableName = toCamelCase(type.name);
+	const fieldsCode = generateFieldsCode(type);
+	return ml`
+    /**
+     * Auto-generated type by plugin: ${pluginId}
+     * Source type: ${sourceTypeName}
+     * Kind: ${kind}
+     *
+     * DO NOT EDIT - This file is generated by @tailor-platform/sdk
+     */
+    import { db } from "@tailor-platform/sdk";
+
+    export const ${variableName} = db.type(${JSON.stringify(type.name)}, ${fieldsCode});
+
+    export type ${type.name} = typeof ${variableName};
+  `;
+}
+/**
+* Generate TypeScript code for field definitions.
+* This creates a simplified version of the type's fields.
+* @param type - TailorDB type
+* @returns TypeScript code for fields object
+*/
+function generateFieldsCode(type) {
+	const fieldEntries = [];
+	for (const [fieldName, field] of Object.entries(type.fields)) {
+		const fieldCode = generateSingleFieldCode(field);
+		if (fieldCode) fieldEntries.push(`  ${fieldName}: ${fieldCode}`);
+	}
+	return `{\n${fieldEntries.join(",\n")},\n}`;
+}
+/**
+* Map from TailorDB type to SDK method name.
+*/
+const typeToMethodMap = {
+	string: "string",
+	integer: "int",
+	float: "float",
+	boolean: "bool",
+	uuid: "uuid",
+	datetime: "datetime",
+	date: "date",
+	time: "time",
+	enum: "enum",
+	nested: "nested"
+};
+/**
+* Generate TypeScript code for a single field definition.
+* @param field - Field definition object
+* @returns TypeScript code for the field
+*/
+function generateSingleFieldCode(field) {
+	if (!field || typeof field !== "object") return null;
+	const fieldType = field.type;
+	if (!fieldType) return null;
+	const method = typeToMethodMap[fieldType] || fieldType;
+	const metadata = field._metadata || field.metadata || {};
+	const optionParts = [];
+	if (metadata.required === false) optionParts.push("optional: true");
+	const optionsArg = optionParts.length > 0 ? `{ ${optionParts.join(", ")} }` : "";
+	if (fieldType === "enum") {
+		const allowedValues = metadata.allowedValues;
+		let enumValues = [];
+		if (Array.isArray(allowedValues)) enumValues = allowedValues.map((v) => v.value);
+		let code$1 = `db.enum(${JSON.stringify(enumValues)}${optionsArg ? `, ${optionsArg}` : ""})`;
+		if (metadata.index) code$1 += ".index()";
+		if (metadata.unique) code$1 += ".unique()";
+		if (metadata.description) code$1 += `.description(${JSON.stringify(metadata.description)})`;
+		return code$1;
+	}
+	let code = `db.${method}(${optionsArg})`;
+	if (metadata.index) code += ".index()";
+	if (metadata.unique) code += ".unique()";
+	if (metadata.description) code += `.description(${JSON.stringify(metadata.description)})`;
+	return code;
+}
+/**
+* Convert plugin ID to safe directory name.
+* @param pluginId - Plugin identifier (e.g., "@tailor-platform/change-history")
+* @returns Safe directory name (e.g., "tailor-platform-change-history")
+*/
+function sanitizePluginId(pluginId) {
+	return pluginId.replace(/^@/, "").replace(/\//g, "-");
+}
+/**
+* Convert string to kebab-case.
+* @param str - Input string
+* @returns kebab-case string
+*/
+function toKebabCase(str) {
+	return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+/**
+* Convert string to camelCase.
+* @param str - Input string
+* @returns camelCase string
+*/
+function toCamelCase(str) {
+	const result = str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "");
+	return result.charAt(0).toLowerCase() + result.slice(1);
+}
 
 //#endregion
 //#region src/cli/type-generator.ts
@@ -4022,9 +4852,10 @@ function extractAttributesFromConfig(config) {
 * @param attributeMap - Attribute map configuration
 * @param attributeList - Attribute list configuration
 * @param env - Environment configuration
+* @param pluginConfigs - Plugin configuration entries for PluginConfigs interface
 * @returns Generated type definition source
 */
-function generateTypeDefinition(attributeMap, attributeList, env) {
+function generateTypeDefinition(attributeMap, attributeList, env, pluginConfigs) {
 	const mapFields = attributeMap ? Object.entries(attributeMap).map(([key, value]) => `    ${key}: ${value};`).join("\n") : "";
 	const mapBody = !attributeMap || Object.keys(attributeMap).length === 0 ? "{}" : `{
 ${mapFields}
@@ -4045,7 +4876,7 @@ declare module "@tailor-platform/sdk" {
   interface AttributeList ${listBody}
   interface Env ${!env || Object.keys(env).length === 0 ? "{}" : `{
 ${envFields}
-  }`}
+  }`}${pluginConfigs && pluginConfigs.length > 0 ? `\n${generatePluginConfigsDefinition(pluginConfigs)}` : ""}${pluginConfigs && pluginConfigs.length > 0 ? `\n${generatePluginMethodOverload(pluginConfigs)}` : ""}
 }
 
 export {};
@@ -4104,11 +4935,11 @@ function resolveTypeDefinitionPath(configPath) {
 }
 /**
 * Generate user type definitions from the app config and write them to disk.
-* @param config - Application config
-* @param configPath - Path to Tailor config file
+* @param options - Generation options
 * @returns Promise that resolves when types are generated
 */
-async function generateUserTypes(config, configPath) {
+async function generateUserTypes(options) {
+	const { config, configPath, plugins } = options;
 	try {
 		const { attributeMap, attributeList } = extractAttributesFromConfig(config);
 		if (!attributeMap && !attributeList) logger.info("No attributes found in configuration", { mode: "plain" });
@@ -4116,7 +4947,14 @@ async function generateUserTypes(config, configPath) {
 		if (attributeList) logger.debug(`Extracted AttributeList: ${JSON.stringify(attributeList)}`);
 		const env = config.env;
 		if (env) logger.debug(`Extracted Env: ${JSON.stringify(env)}`);
-		const typeDefContent = generateTypeDefinition(attributeMap, attributeList, env);
+		const pluginConfigs = plugins?.filter((p) => p.configSchema !== void 0).map((p) => ({
+			id: p.id,
+			configSchema: p.configSchema,
+			configTypeTemplate: p.configTypeTemplate,
+			typeConfigRequired: isTypeConfigRequired(p)
+		}));
+		if (pluginConfigs && pluginConfigs.length > 0) logger.debug(`Extracted PluginConfigs: ${pluginConfigs.map((p) => p.id).join(", ")}`);
+		const typeDefContent = generateTypeDefinition(attributeMap, attributeList, env, pluginConfigs);
 		const outputPath = resolveTypeDefinitionPath(configPath);
 		fs$2.mkdirSync(path.dirname(outputPath), { recursive: true });
 		fs$2.writeFileSync(outputPath, typeDefContent);
@@ -4145,6 +4983,386 @@ function resolvePackageDirectory(startDir) {
 		return null;
 	}
 }
+/**
+* Convert a ConfigSchemaField to its TypeScript type string representation.
+* @param field - The field to convert
+* @param indent - Current indentation level
+* @returns TypeScript type string
+*/
+function fieldToTypeString(field, indent = 0) {
+	const indentStr = "  ".repeat(indent);
+	const metadata = field.metadata;
+	let baseType;
+	switch (field.type) {
+		case "string":
+		case "uuid":
+		case "date":
+		case "datetime":
+		case "time":
+			baseType = "string";
+			break;
+		case "integer":
+		case "float":
+			baseType = "number";
+			break;
+		case "boolean":
+			baseType = "boolean";
+			break;
+		case "enum":
+			if (metadata.allowedValues && metadata.allowedValues.length > 0) baseType = metadata.allowedValues.map((v) => `"${v.value}"`).join(" | ");
+			else baseType = "string";
+			break;
+		case "nested": {
+			const fieldEntries = Object.entries(field.fields);
+			if (fieldEntries.length === 0) baseType = "Record<string, unknown>";
+			else baseType = `{\n${fieldEntries.map(([name, nestedField]) => {
+				const nestedType = fieldToTypeString(nestedField, indent + 1);
+				return `${indentStr}  ${name}${!nestedField.metadata.required ? "?" : ""}: ${nestedType};`;
+			}).join("\n")}\n${indentStr}}`;
+			break;
+		}
+		default: baseType = "unknown";
+	}
+	if (metadata.array) baseType = `(${baseType})[]`;
+	return baseType;
+}
+function isTypeConfigRequired(plugin) {
+	const required = plugin.typeConfigRequired;
+	if (typeof required === "function") return required(plugin.pluginConfig);
+	return required === true;
+}
+/**
+* Generate PluginConfigs interface extension for user-defined.d.ts
+* @param plugins - Array of plugin configurations
+* @returns TypeScript interface extension string, or empty string if no plugins
+*/
+function generatePluginConfigsDefinition(plugins) {
+	if (plugins.length === 0) return "";
+	return `  interface PluginConfigs<Fields extends string> {
+${plugins.map((plugin) => {
+		const typeString = plugin.configTypeTemplate ?? fieldToTypeString(plugin.configSchema, 2);
+		const optionalMarker = plugin.typeConfigRequired ? "" : "?";
+		return `    "${plugin.id}"${optionalMarker}: ${typeString};`;
+	}).join("\n")}
+  }`;
+}
+/**
+* Generate TailorDBType.plugin() method overload for IDE completion.
+* This adds an overload that uses `keyof Fields` directly for field-aware types,
+* enabling IDE autocompletion for field names in plugin configs.
+* @param plugins - Array of plugin configurations
+* @returns TypeScript interface extension string
+*/
+function generatePluginMethodOverload(plugins) {
+	return `  // Overload for .plugin() method to enable IDE completion for field names
+  interface TailorDBType<Fields, User> {
+    plugin(config: {
+${plugins.map((plugin) => {
+		const typeString = (plugin.configTypeTemplate ?? fieldToTypeString(plugin.configSchema, 3)).replace(/\bFields\b/g, "keyof Fields & string");
+		const optionalMarker = plugin.typeConfigRequired ? "" : "?";
+		return `      "${plugin.id}"${optionalMarker}: ${typeString};`;
+	}).join("\n")}
+    }): this;
+  }`;
+}
+
+//#endregion
+//#region src/plugin/manager.ts
+const unauthenticatedTailorUser = {
+	id: "00000000-0000-0000-0000-000000000000",
+	type: "",
+	workspaceId: "00000000-0000-0000-0000-000000000000",
+	attributes: null,
+	attributeList: []
+};
+/**
+* Validate plugin config against its schema
+* @param config - The config object to validate
+* @param schema - The schema defining expected fields
+* @returns Array of validation errors (empty if valid)
+*/
+function validatePluginConfig(config, schema) {
+	const result = schema.parse({
+		value: config,
+		data: config,
+		user: unauthenticatedTailorUser
+	});
+	if ("issues" in result && result.issues) return result.issues.map((issue) => ({
+		field: Array.isArray(issue.path) ? issue.path.join(".") : "",
+		message: issue.message
+	}));
+	return [];
+}
+/**
+* Manages plugin registration and processing
+*/
+var PluginManager = class {
+	plugins = /* @__PURE__ */ new Map();
+	generatedExecutors = [];
+	generatedTypes = [];
+	namespaceGeneratedTypeKeys = /* @__PURE__ */ new Set();
+	namespaceGeneratedExecutorKeys = /* @__PURE__ */ new Set();
+	constructor(plugins = []) {
+		for (const plugin of plugins) {
+			if (this.plugins.has(plugin.id)) throw new Error(`Duplicate plugin ID "${plugin.id}" detected. Each plugin must have a unique ID.`);
+			this.plugins.set(plugin.id, plugin);
+		}
+	}
+	/**
+	* Process a single plugin attachment on a raw TailorDBType.
+	* This method is called during type loading before parsing.
+	* @param context - Context containing the raw type, config, namespace, and plugin ID
+	* @returns Result with plugin output on success, or error message on failure
+	*/
+	async processAttachment(context) {
+		const plugin = this.plugins.get(context.pluginId);
+		if (!plugin) return {
+			success: false,
+			error: `Plugin "${context.pluginId}" not found`
+		};
+		const typeConfigRequired = plugin.typeConfigRequired;
+		if ((typeof typeConfigRequired === "function" ? typeConfigRequired(plugin.pluginConfig) : typeConfigRequired === true) && (context.config === void 0 || context.config === null)) return {
+			success: false,
+			error: `Plugin "${plugin.id}" requires config, but none was provided for type "${context.type.name}".`
+		};
+		if (plugin.configSchema) {
+			const validationErrors = validatePluginConfig(context.config, plugin.configSchema);
+			if (validationErrors.length > 0) {
+				const errorDetails = validationErrors.map((e) => e.field ? `${e.field}: ${e.message}` : e.message).join("; ");
+				return {
+					success: false,
+					error: `Invalid config for plugin "${plugin.id}" on type "${context.type.name}": ${errorDetails}`
+				};
+			}
+		}
+		if (!plugin.process) return {
+			success: false,
+			error: `Plugin "${plugin.id}" does not support type-attached processing (missing process method). Use processNamespace via definePlugins() instead.`
+		};
+		let output;
+		try {
+			output = await plugin.process({
+				type: context.type,
+				config: context.config,
+				pluginConfig: plugin.pluginConfig,
+				namespace: context.namespace
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return {
+				success: false,
+				error: `Plugin "${plugin.id}" threw an error while processing type "${context.type.name}": ${message}`
+			};
+		}
+		if (output.types && Object.keys(output.types).length > 0) {
+			const importPath = plugin.importPath;
+			for (const [kind, type] of Object.entries(output.types)) this.generatedTypes.push({
+				pluginId: context.pluginId,
+				pluginImportPath: importPath,
+				sourceTypeName: context.type.name,
+				kind,
+				type
+			});
+		}
+		if (output.executors && output.executors.length > 0) for (const executor of output.executors) this.generatedExecutors.push({
+			executor,
+			pluginId: context.pluginId,
+			namespace: context.namespace,
+			sourceTypeName: context.type.name
+		});
+		return {
+			success: true,
+			output
+		};
+	}
+	/**
+	* Process namespace plugins that don't require a source type.
+	* This method is called once per namespace for plugins with processNamespace method.
+	* @param namespace - The target namespace for generated types
+	* @param types - TailorDB types in the namespace (after type-attached processing)
+	* @param generatedTypes - Plugin-generated types in the namespace
+	* @returns Array of results with plugin outputs and configs
+	*/
+	async processNamespacePlugins(namespace, types, generatedTypes) {
+		const results = [];
+		for (const [pluginId, plugin] of this.plugins) {
+			if (!plugin.processNamespace) continue;
+			const config = plugin.pluginConfig;
+			if (plugin.pluginConfigSchema && config !== void 0) {
+				const validationErrors = validatePluginConfig(config, plugin.pluginConfigSchema);
+				if (validationErrors.length > 0) {
+					const errorDetails = validationErrors.map((e) => e.field ? `${e.field}: ${e.message}` : e.message).join("; ");
+					results.push({
+						pluginId,
+						config,
+						result: {
+							success: false,
+							error: `Invalid pluginConfig for plugin "${plugin.id}": ${errorDetails}`
+						}
+					});
+					continue;
+				}
+			}
+			const context = {
+				pluginConfig: config,
+				namespace,
+				types,
+				generatedTypes
+			};
+			let output;
+			try {
+				output = await plugin.processNamespace(context);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				results.push({
+					pluginId,
+					config,
+					result: {
+						success: false,
+						error: `Plugin "${plugin.id}" threw an error during namespace processing for "${namespace}": ${message}`
+					}
+				});
+				continue;
+			}
+			if (output.executors && output.executors.length > 0) for (const executor of output.executors) {
+				const executorKey = `${pluginId}:${executor.name}`;
+				if (this.namespaceGeneratedExecutorKeys.has(executorKey)) continue;
+				this.namespaceGeneratedExecutorKeys.add(executorKey);
+				this.generatedExecutors.push({
+					executor,
+					pluginId,
+					namespace
+				});
+			}
+			if (output.types && Object.keys(output.types).length > 0) {
+				const importPath = plugin.importPath;
+				for (const [kind, type] of Object.entries(output.types)) {
+					const typeKey = `${pluginId}:${kind}:${type.name}`;
+					if (this.namespaceGeneratedTypeKeys.has(typeKey)) continue;
+					this.namespaceGeneratedTypeKeys.add(typeKey);
+					this.generatedTypes.push({
+						pluginId,
+						pluginImportPath: importPath,
+						sourceTypeName: "(namespace)",
+						kind,
+						type
+					});
+				}
+			}
+			results.push({
+				pluginId,
+				config,
+				result: {
+					success: true,
+					output
+				}
+			});
+		}
+		return results;
+	}
+	/**
+	* Get plugins that have processNamespace method
+	* @returns Array of plugin IDs that support namespace processing
+	*/
+	getNamespacePluginIds() {
+		return Array.from(this.plugins.entries()).filter(([, plugin]) => plugin.processNamespace !== void 0).map(([id]) => id);
+	}
+	/**
+	* Get the count of registered plugins
+	* @returns Number of registered plugins
+	*/
+	get pluginCount() {
+		return this.plugins.size;
+	}
+	/**
+	* Get the import path for a plugin
+	* @param pluginId - The plugin ID to look up
+	* @returns The plugin's import path, or undefined if not found
+	*/
+	getPluginImportPath(pluginId) {
+		return this.plugins.get(pluginId)?.importPath;
+	}
+	/**
+	* Get all plugin-generated executors
+	* @returns Array of plugin-generated executor info
+	*/
+	getPluginGeneratedExecutors() {
+		return this.generatedExecutors;
+	}
+	/**
+	* Get all plugin-generated executors with import paths
+	* @returns Array of plugin-generated executor info with import paths
+	*/
+	getPluginGeneratedExecutorsWithImportPath() {
+		return this.generatedExecutors.map((info) => ({
+			...info,
+			pluginImportPath: this.getPluginImportPath(info.pluginId) ?? ""
+		}));
+	}
+	/**
+	* Get all plugin-generated types
+	* @returns Array of plugin-generated type info
+	*/
+	getPluginGeneratedTypes() {
+		return this.generatedTypes;
+	}
+	/**
+	* Get plugin-generated executors for a specific namespace
+	* @param namespace - The namespace to filter by
+	* @returns Array of plugin-generated executor info for the namespace
+	*/
+	getPluginGeneratedExecutorsForNamespace(namespace) {
+		return this.generatedExecutors.filter((info) => info.namespace === namespace);
+	}
+	/**
+	* Extend a TailorDB type with new fields.
+	* This method handles the `db.type()` call and metadata copying internally.
+	* @param params - Parameters for type extension
+	* @returns The extended TailorDB type
+	*/
+	extendType(params) {
+		const { originalType, extendFields, pluginId } = params;
+		const existingFieldNames = Object.keys(originalType.fields);
+		const duplicateFields = Object.keys(extendFields).filter((name) => existingFieldNames.includes(name));
+		if (duplicateFields.length > 0) throw new Error(`Plugin "${pluginId}" attempted to add fields that already exist in type "${originalType.name}": ${duplicateFields.join(", ")}. extendFields cannot overwrite existing fields.`);
+		const { id: _id, ...fieldsWithoutId } = {
+			...originalType.fields,
+			...extendFields
+		};
+		const pluralForm = originalType.metadata.settings?.pluralForm;
+		const typeName = pluralForm ? [originalType.name, pluralForm] : originalType.name;
+		return copyMetadataToExtendedType(originalType, db.type(typeName, fieldsWithoutId));
+	}
+};
+/**
+* Copy metadata from original type to extended type.
+* Preserves files, settings, permissions, indexes, and plugins.
+* @param original - The original TailorDB type with metadata
+* @param extended - The newly created extended type
+* @returns The extended type with copied metadata
+*/
+function copyMetadataToExtendedType(original, extended) {
+	let result = extended;
+	if (original._description) result = result.description(original._description);
+	const metadata = original.metadata;
+	if (metadata.files && Object.keys(metadata.files).length > 0) result = result.files(metadata.files);
+	if (metadata.settings) {
+		const { pluralForm: _pluralForm, ...features } = metadata.settings;
+		if (Object.keys(features).length > 0) result = result.features(features);
+	}
+	if (metadata.permissions?.record) result = result.permission(metadata.permissions.record);
+	if (metadata.permissions?.gql) result = result.gqlPermission(metadata.permissions.gql);
+	if (metadata.indexes && Object.keys(metadata.indexes).length > 0) {
+		const indexDefs = Object.entries(metadata.indexes).map(([name, def]) => ({
+			name,
+			fields: def.fields,
+			unique: def.unique
+		}));
+		result = result.indexes(...indexDefs);
+	}
+	if (original.plugins && original.plugins.length > 0) for (const plugin of original.plugins) result = result.plugin({ [plugin.pluginId]: plugin.config });
+	return result;
+}
 
 //#endregion
 //#region src/cli/apply/services/label.ts
@@ -4188,12 +5406,14 @@ function createChangeSet(title) {
 	const creates = [];
 	const updates = [];
 	const deletes = [];
-	const isEmpty = () => creates.length === 0 && updates.length === 0 && deletes.length === 0;
+	const replaces = [];
+	const isEmpty = () => creates.length === 0 && updates.length === 0 && deletes.length === 0 && replaces.length === 0;
 	return {
 		title,
 		creates,
 		updates,
 		deletes,
+		replaces,
 		isEmpty,
 		print: () => {
 			if (isEmpty()) return;
@@ -4201,6 +5421,7 @@ function createChangeSet(title) {
 			creates.forEach((item) => logger.log(`  ${symbols.create} ${item.name}`));
 			deletes.forEach((item) => logger.log(`  ${symbols.delete} ${item.name}`));
 			updates.forEach((item) => logger.log(`  ${symbols.update} ${item.name}`));
+			replaces.forEach((item) => logger.log(`  ${symbols.replace} ${item.name}`));
 		}
 	};
 }
@@ -4654,6 +5875,11 @@ async function applyAuth(client, result, phase = "create-update") {
 			update.request.oauth2Client.redirectUris = await resolveStaticWebsiteUrls(client, update.request.workspaceId, update.request.oauth2Client.redirectUris, "OAuth2 redirect URIs");
 			return client.updateAuthOAuth2Client(update.request);
 		})]);
+		for (const replace of changeSet.oauth2Client.replaces) {
+			await client.deleteAuthOAuth2Client(replace.deleteRequest);
+			replace.createRequest.oauth2Client.redirectUris = await resolveStaticWebsiteUrls(client, replace.createRequest.workspaceId, replace.createRequest.oauth2Client.redirectUris, "OAuth2 redirect URIs");
+			await client.createAuthOAuth2Client(replace.createRequest);
+		}
 		await Promise.all([...changeSet.scim.creates.map((create$1) => client.createAuthSCIMConfig(create$1.request)), ...changeSet.scim.updates.map((update) => client.updateAuthSCIMConfig(update.request))]);
 		await Promise.all([...changeSet.scimResource.creates.map((create$1) => client.createAuthSCIMResource(create$1.request)), ...changeSet.scimResource.updates.map((update) => client.updateAuthSCIMResource(update.request))]);
 	} else if (phase === "delete-resources") {
@@ -5193,33 +6419,47 @@ async function planOAuth2Clients(client, workspaceId, auths, deletedServices) {
 	for (const auth of auths) {
 		const { parsedConfig: config } = auth;
 		const existingOAuth2Clients = await fetchOAuth2Clients(config.name);
-		const existingNameSet = /* @__PURE__ */ new Set();
+		const existingClientsMap = /* @__PURE__ */ new Map();
 		existingOAuth2Clients.forEach((oauth2Client) => {
-			existingNameSet.add(oauth2Client.name);
+			existingClientsMap.set(oauth2Client.name, oauth2Client.clientType);
 		});
 		for (const oauth2ClientName of Object.keys(config.oauth2Clients ?? {})) {
 			const oauth2Client = config.oauth2Clients?.[oauth2ClientName];
 			if (!oauth2Client) continue;
-			if (existingNameSet.has(oauth2ClientName)) {
-				changeSet.updates.push({
+			const newOAuth2Client = protoOAuth2Client(oauth2ClientName, oauth2Client);
+			if (existingClientsMap.has(oauth2ClientName)) {
+				if (existingClientsMap.get(oauth2ClientName) !== newOAuth2Client.clientType) changeSet.replaces.push({
+					name: oauth2ClientName,
+					deleteRequest: {
+						workspaceId,
+						namespaceName: config.name,
+						name: oauth2ClientName
+					},
+					createRequest: {
+						workspaceId,
+						namespaceName: config.name,
+						oauth2Client: newOAuth2Client
+					}
+				});
+				else changeSet.updates.push({
 					name: oauth2ClientName,
 					request: {
 						workspaceId,
 						namespaceName: config.name,
-						oauth2Client: protoOAuth2Client(oauth2ClientName, oauth2Client)
+						oauth2Client: newOAuth2Client
 					}
 				});
-				existingNameSet.delete(oauth2ClientName);
+				existingClientsMap.delete(oauth2ClientName);
 			} else changeSet.creates.push({
 				name: oauth2ClientName,
 				request: {
 					workspaceId,
 					namespaceName: config.name,
-					oauth2Client: protoOAuth2Client(oauth2ClientName, oauth2Client)
+					oauth2Client: newOAuth2Client
 				}
 			});
 		}
-		existingNameSet.forEach((name) => {
+		existingClientsMap.forEach((_, name) => {
 			changeSet.deletes.push({
 				name,
 				request: {
@@ -7034,46 +8274,7 @@ function assertValidMigrationFiles(migrationsDir, namespace) {
 	}
 }
 /**
-* Filter a TailorDBType to match the schema state in a snapshot
-* This is used when TAILOR_INTERNAL_APPLY_MIGRATION_VERSION is specified to ensure
-* the deployed schema matches the specified migration version
-* @param {TailorDBType} type - Local parsed type (latest state)
-* @param {SnapshotType} snapshotType - Target snapshot state
-* @returns {TailorDBType} Filtered type matching the snapshot
-*/
-function filterTypeToSnapshot(type, snapshotType) {
-	const filteredFields = {};
-	if (type.fields.id) filteredFields.id = type.fields.id;
-	for (const fieldName of Object.keys(snapshotType.fields)) if (type.fields[fieldName]) {
-		const snapshotFieldConfig = snapshotType.fields[fieldName];
-		const localField = type.fields[fieldName];
-		filteredFields[fieldName] = {
-			...localField,
-			config: {
-				...localField.config,
-				required: snapshotFieldConfig.required,
-				index: snapshotFieldConfig.index || false,
-				unique: snapshotFieldConfig.unique || false,
-				...snapshotFieldConfig.type === "enum" && snapshotFieldConfig.allowedValues && { allowedValues: snapshotFieldConfig.allowedValues.map((v) => typeof v === "string" ? { value: v } : v) }
-			}
-		};
-	}
-	const filteredIndexes = {};
-	if (snapshotType.indexes) for (const [indexName, indexConfig] of Object.entries(snapshotType.indexes)) filteredIndexes[indexName] = {
-		fields: indexConfig.fields,
-		unique: indexConfig.unique
-	};
-	const filteredFiles = {};
-	if (snapshotType.files) for (const [fileName, description] of Object.entries(snapshotType.files)) filteredFiles[fileName] = description;
-	return {
-		...type,
-		fields: filteredFields,
-		indexes: Object.keys(filteredIndexes).length > 0 ? filteredIndexes : void 0,
-		files: Object.keys(filteredFiles).length > 0 ? filteredFiles : void 0
-	};
-}
-/**
-* Convert remote TailorDBType to SnapshotFieldConfig for comparison
+* Convert remote ParsedTailorDBType to SnapshotFieldConfig for comparison
 * @param {ProtoTailorDBType} remoteType - Remote TailorDB type from API
 * @returns {Record<string, SnapshotFieldConfig>} Converted field configs
 */
@@ -7147,7 +8348,7 @@ function compareFields(typeName, fieldName, remoteField, snapshotField) {
 const SYSTEM_FIELDS = new Set(["id"]);
 /**
 * Compare remote TailorDB types with a local snapshot
-* @param {ProtoTailorDBType[]} remoteTypes - Remote types from listTailorDBTypes API
+* @param {ProtoTailorDBType[]} remoteTypes - Remote types from listParsedTailorDBTypes API
 * @param {SchemaSnapshot} snapshot - Local schema snapshot
 * @returns {SchemaDrift[]} List of drifts detected
 */
@@ -7224,24 +8425,6 @@ function formatSchemaDrifts(drifts) {
 *
 * Bundles migration scripts to be executed via TestExecScript API
 */
-const REQUIRED_PACKAGES = ["kysely", "@tailor-platform/function-kysely-tailordb"];
-let dependencyCheckDone = false;
-/**
-* Check if required packages for migration bundling are installed.
-* Logs a warning if any are missing.
-*/
-function checkMigrationDependencies() {
-	if (dependencyCheckDone) return;
-	dependencyCheckDone = true;
-	const require$1 = createRequire(path.resolve(process.cwd(), "package.json"));
-	const missing = [];
-	for (const pkg of REQUIRED_PACKAGES) try {
-		require$1.resolve(pkg);
-	} catch {
-		missing.push(pkg);
-	}
-	if (missing.length > 0) logger.warn(`Missing optional dependencies for migration bundling: ${missing.join(", ")}. Install them in your project: pnpm add -D ${missing.join(" ")}`);
-}
 /**
 * Bundle a single migration script
 *
@@ -7256,15 +8439,13 @@ function checkMigrationDependencies() {
 * @returns {Promise<MigrationBundleResult>} Bundled migration result
 */
 async function bundleMigrationScript(sourceFile, namespace, migrationNumber) {
-	checkMigrationDependencies();
 	const outputDir = path.resolve(getDistDir(), "migrations");
 	fs$2.mkdirSync(outputDir, { recursive: true });
 	const entryPath = path.join(outputDir, `migration_${namespace}_${migrationNumber}.entry.js`);
 	const outputPath = path.join(outputDir, `migration_${namespace}_${migrationNumber}.js`);
 	const entryContent = ml`
     import { main as _migrationMain } from "${path.resolve(sourceFile).replace(/\\/g, "/")}";
-    import { Kysely } from "kysely";
-    import { TailordbDialect } from "@tailor-platform/function-kysely-tailordb";
+    import { Kysely, TailordbDialect } from "@tailor-platform/sdk/kysely";
 
     function getDB(namespace) {
       const client = new tailordb.Client({ namespace });
@@ -7446,19 +8627,11 @@ async function getCurrentMigrationNumber(client, workspaceId, namespace) {
 */
 async function detectPendingMigrations(client, workspaceId, namespacesWithMigrations) {
 	const pendingMigrations = [];
-	const maxVersionEnv = process.env.TAILOR_INTERNAL_APPLY_MIGRATION_VERSION;
-	const maxVersion = maxVersionEnv ? parseInt(maxVersionEnv, 10) : void 0;
-	if (maxVersion !== void 0 && !Number.isInteger(maxVersion)) throw new Error(`Invalid TAILOR_INTERNAL_APPLY_MIGRATION_VERSION: "${maxVersionEnv}". Must be a valid integer.`);
-	if (maxVersion !== void 0) {
-		logger.newline();
-		logger.info(`Limiting migrations to version ${styles.bold(formatMigrationNumber(maxVersion))} or earlier`);
-	}
 	for (const { namespace, migrationsDir } of namespacesWithMigrations) {
 		const currentMigration = await getCurrentMigrationNumber(client, workspaceId, namespace);
 		const migrationFiles = getMigrationFiles(migrationsDir);
 		for (const file of migrationFiles) {
 			if (file.number <= currentMigration) continue;
-			if (maxVersion !== void 0 && file.number > maxVersion) continue;
 			const diffPath = getMigrationFilePath(migrationsDir, file.number, "diff");
 			if (!fs$2.existsSync(diffPath)) continue;
 			const diff = loadDiff(diffPath);
@@ -7597,35 +8770,6 @@ function groupMigrationsByNamespace(migrations) {
 	}
 	return grouped;
 }
-/**
-* Build filtered types map for a specific migration version
-* @param {number} maxVersion - Maximum migration version to reconstruct
-* @param {Application} application - Application instance
-* @param {LoadedConfig} config - Loaded application config (includes path)
-* @returns {Promise<Map<string, Record<string, TailorDBType>>>} Filtered types by namespace
-*/
-async function buildFilteredTypesForVersion(maxVersion, application, config) {
-	const namespacesWithMigrations = getNamespacesWithMigrations(config, path.dirname(config.path));
-	const filteredTypesByNamespace = /* @__PURE__ */ new Map();
-	for (const { namespace, migrationsDir } of namespacesWithMigrations) {
-		const snapshot = reconstructSnapshotFromMigrations(migrationsDir, maxVersion);
-		if (!snapshot) throw new Error(`No migrations found in ${migrationsDir}`);
-		const tailordb = application.tailorDBServices.find((tdb) => tdb.namespace === namespace);
-		if (!tailordb) throw new Error(`TailorDB service not found for namespace: ${namespace}`);
-		await tailordb.loadTypes();
-		const localTypes = tailordb.getTypes();
-		const filteredTypes = {};
-		for (const typeName of Object.keys(snapshot.types)) {
-			const localType = localTypes[typeName];
-			if (localType) {
-				const snapshotType = snapshot.types[typeName];
-				filteredTypes[typeName] = filterTypeToSnapshot(localType, snapshotType);
-			}
-		}
-		filteredTypesByNamespace.set(namespace, filteredTypes);
-	}
-	return filteredTypesByNamespace;
-}
 
 //#endregion
 //#region src/cli/apply/services/tailordb/index.ts
@@ -7778,11 +8922,30 @@ async function validateAndDetectMigrations(client, workspaceId, typesByNamespace
 	return pendingMigrations;
 }
 /**
+* Build migration execution context for script-based migrations.
+* @param client - Operator client instance
+* @param migrationContext - Planned TailorDB context
+* @param migrationsRequiringScripts - Migrations that require scripts
+* @returns Migration context for script execution
+*/
+function buildMigrationContextForScripts(client, migrationContext, migrationsRequiringScripts) {
+	const authService = migrationContext.application.authService;
+	if (!authService) throw new Error("Auth configuration is required to execute migration scripts.");
+	const dbConfigMap = {};
+	for (const migration of migrationsRequiringScripts) if (!(migration.namespace in dbConfigMap)) dbConfigMap[migration.namespace] = migrationContext.config.db?.[migration.namespace];
+	return {
+		client,
+		workspaceId: migrationContext.workspaceId,
+		authNamespace: authService.config.name,
+		machineUsers: authService.config.machineUsers ? Object.keys(authService.config.machineUsers) : void 0,
+		dbConfig: dbConfigMap
+	};
+}
+/**
 * Apply TailorDB-related changes for the given phase.
 * @param client - Operator client instance
 * @param result - Planned TailorDB changes
 * @param phase - Apply phase (defaults to "create-update")
-* @returns Promise that resolves when TailorDB changes are applied
 */
 async function applyTailorDB(client, result, phase = "create-update") {
 	const { changeSet, context: migrationContext } = result;
@@ -7798,21 +8961,8 @@ async function applyTailorDB(client, result, phase = "create-update") {
 			processedTypes.reset();
 			deletedResources.reset();
 			await executeServicesCreation(client, changeSet);
-			let migrationCtx;
 			const migrationsRequiringScripts = pendingMigrations.filter((m) => m.diff.requiresMigrationScript);
-			if (migrationsRequiringScripts.length > 0) {
-				const authService = migrationContext.application.authService;
-				if (!authService) throw new Error("Auth configuration is required to execute migration scripts.");
-				const dbConfigMap = {};
-				for (const migration of migrationsRequiringScripts) if (!(migration.namespace in dbConfigMap)) dbConfigMap[migration.namespace] = migrationContext.config.db?.[migration.namespace];
-				migrationCtx = {
-					client,
-					workspaceId: migrationContext.workspaceId,
-					authNamespace: authService.config.name,
-					machineUsers: authService.config.machineUsers ? Object.keys(authService.config.machineUsers) : void 0,
-					dbConfig: dbConfigMap
-				};
-			}
+			const migrationCtx = migrationsRequiringScripts.length > 0 ? buildMigrationContextForScripts(client, migrationContext, migrationsRequiringScripts) : void 0;
 			if (migrationsRequiringScripts.length > 0) {
 				logger.info(`Executing ${migrationsRequiringScripts.length} data migration(s)...`);
 				logger.newline();
@@ -7850,17 +9000,6 @@ async function applyTailorDB(client, result, phase = "create-update") {
 		await Promise.all(changeSet.gqlPermission.deletes.map((del) => client.deleteTailorDBGQLPermission(del.request)));
 		await Promise.all(changeSet.type.deletes.map((del) => client.deleteTailorDBType(del.request)));
 	} else if (phase === "delete-services") await Promise.all(changeSet.service.deletes.map((del) => client.deleteTailorDBService(del.request)));
-	if (phase === "create-update") {
-		const maxVersionEnv = process.env.TAILOR_INTERNAL_APPLY_MIGRATION_VERSION;
-		if (maxVersionEnv) {
-			const maxVersion = parseInt(maxVersionEnv, 10);
-			if (Number.isInteger(maxVersion)) {
-				const configDir = path.dirname(migrationContext.config.path);
-				const namespacesWithMigrations = getNamespacesWithMigrations(migrationContext.config, configDir);
-				for (const { namespace } of namespacesWithMigrations) await updateMigrationLabel(client, migrationContext.workspaceId, namespace, maxVersion);
-			}
-		}
-	}
 }
 /**
 * Handle optional-to-required field change error with helpful message
@@ -7890,23 +9029,27 @@ function buildBreakingChangesMap(pendingMigrations) {
 	return map;
 }
 /**
-* Check if a field change requires pre/post-migration handling
-* - Adding a required field (pre: add as optional, post: make required)
-* - Changing optional to required (post: make required)
-* - Adding unique constraint (post: add unique)
-* - Removing enum values (pre: add new values only, post: remove old values)
-* @param {DiffChange} change - Diff change to check
-* @returns {boolean} True if the change requires pre/post-migration handling
+* Apply pre-migration schema adjustments to avoid breaking changes before scripts run.
+* @param fields - Field configs to adjust
+* @param typeChanges - Breaking changes for a type
 */
-function isBreakingChange(change) {
-	const before = change.before;
-	const after = change.after;
-	if (change.kind === "field_added") return after?.required === true;
-	if (change.kind !== "field_modified") return false;
-	if (!before?.required && after?.required) return true;
-	if (!(before?.unique ?? false) && (after?.unique ?? false)) return true;
-	if (before?.allowedValues && after?.allowedValues) return before.allowedValues.some((v) => !after.allowedValues.includes(v));
-	return false;
+function applyPreMigrationFieldAdjustments(fields, typeChanges) {
+	for (const [fieldName, change] of typeChanges) {
+		const field = fields[fieldName];
+		if (!field) continue;
+		const before = change.before;
+		const after = change.after;
+		if (change.kind === "field_added" && after?.required) field.required = false;
+		if (change.kind !== "field_modified") continue;
+		if (!before?.required && after?.required) field.required = false;
+		if (!(before?.unique ?? false) && (after?.unique ?? false)) field.unique = false;
+		if (before?.allowedValues && after?.allowedValues) {
+			if (before.allowedValues.filter((value) => !after.allowedValues.includes(value)).length > 0) field.allowedValues = [...new Set([...before.allowedValues, ...after.allowedValues])].map((value) => ({
+				value,
+				description: ""
+			}));
+		}
+	}
 }
 /**
 * Get the set of type names affected by a migration
@@ -7946,11 +9089,11 @@ async function executeServicesCreation(client, changeSet) {
 const processedTypes = {
 	created: /* @__PURE__ */ new Set(),
 	updated: /* @__PURE__ */ new Set(),
-	gqlPermissionsProcessed: false,
+	gqlPermissionsProcessed: /* @__PURE__ */ new Set(),
 	reset() {
 		this.created.clear();
 		this.updated.clear();
-		this.gqlPermissionsProcessed = false;
+		this.gqlPermissionsProcessed.clear();
 	}
 };
 /**
@@ -7963,57 +9106,68 @@ const processedTypes = {
 async function executeSingleMigrationPrePhase(client, changeSet, migration) {
 	const breakingChanges = buildBreakingChangesMap([migration]);
 	const affectedTypes = getAffectedTypeNames(migration);
-	await Promise.all([...changeSet.type.creates.filter((create$1) => {
-		const typeName = create$1.request.tailordbType?.name;
-		return typeName && affectedTypes.has(typeName) && !processedTypes.created.has(typeName);
-	}).map((create$1) => {
-		const typeName = create$1.request.tailordbType?.name;
-		if (typeName) processedTypes.created.add(typeName);
-		const typeChanges = typeName ? breakingChanges.get(typeName) : void 0;
-		if (!typeChanges || typeChanges.size === 0) return client.createTailorDBType(create$1.request);
-		const clonedRequest = structuredClone(create$1.request);
-		if (clonedRequest.tailordbType?.schema?.fields) {
-			const fields = clonedRequest.tailordbType.schema.fields;
-			for (const [fieldName, change] of typeChanges) {
-				if (!isBreakingChange(change) || !fields[fieldName]) continue;
-				const after = change.after;
-				if (change.kind === "field_added" && after?.required) fields[fieldName].required = false;
-			}
-		}
-		return client.createTailorDBType(clonedRequest);
-	}), ...changeSet.type.updates.filter((update) => {
-		const typeName = update.request.tailordbType?.name;
-		return typeName && affectedTypes.has(typeName);
-	}).map((update) => {
-		const typeName = update.request.tailordbType?.name;
-		if (typeName) processedTypes.updated.add(typeName);
-		const typeChanges = typeName ? breakingChanges.get(typeName) : void 0;
-		if (!typeChanges || typeChanges.size === 0) return client.updateTailorDBType(update.request);
-		const clonedRequest = structuredClone(update.request);
-		if (clonedRequest.tailordbType?.schema?.fields) {
-			const fields = clonedRequest.tailordbType.schema.fields;
-			for (const [fieldName, change] of typeChanges) {
-				if (!isBreakingChange(change) || !fields[fieldName]) continue;
-				const before = change.before;
-				const after = change.after;
-				if (change.kind === "field_added" && after?.required) fields[fieldName].required = false;
-				if (change.kind === "field_modified" && !(before?.unique ?? false) && (after?.unique ?? false)) fields[fieldName].unique = false;
-				if (change.kind === "field_modified" && before?.allowedValues && after?.allowedValues) {
-					if (before.allowedValues.filter((v) => !after.allowedValues.includes(v)).length > 0) {
-						const unionValues = [...new Set([...before.allowedValues, ...after.allowedValues])];
-						fields[fieldName].allowedValues = unionValues.map((v) => ({
-							value: v,
-							description: ""
-						}));
-					}
-				}
-			}
-		}
-		return client.updateTailorDBType(clonedRequest);
-	})]);
-	if (!processedTypes.gqlPermissionsProcessed) {
-		processedTypes.gqlPermissionsProcessed = true;
-		await Promise.all([...changeSet.gqlPermission.creates.map((create$1) => client.createTailorDBGQLPermission(create$1.request)), ...changeSet.gqlPermission.updates.map((update) => client.updateTailorDBGQLPermission(update.request))]);
+	const createdBeforeMigration = new Set(processedTypes.created);
+	await Promise.all([
+		...changeSet.type.creates.filter((create$1) => {
+			const typeName = create$1.request.tailordbType?.name;
+			return typeName && affectedTypes.has(typeName) && !createdBeforeMigration.has(typeName);
+		}).map((create$1) => {
+			const typeName = create$1.request.tailordbType?.name;
+			if (typeName) processedTypes.created.add(typeName);
+			const typeChanges = typeName ? breakingChanges.get(typeName) : void 0;
+			if (!typeChanges || typeChanges.size === 0) return client.createTailorDBType(create$1.request);
+			const clonedRequest = structuredClone(create$1.request);
+			if (clonedRequest.tailordbType?.schema?.fields) applyPreMigrationFieldAdjustments(clonedRequest.tailordbType.schema.fields, typeChanges);
+			return client.createTailorDBType(clonedRequest);
+		}),
+		...changeSet.type.creates.filter((create$1) => {
+			const typeName = create$1.request.tailordbType?.name;
+			return typeName && affectedTypes.has(typeName) && createdBeforeMigration.has(typeName);
+		}).map((create$1) => {
+			const typeName = create$1.request.tailordbType?.name;
+			if (typeName) processedTypes.updated.add(typeName);
+			const typeChanges = typeName ? breakingChanges.get(typeName) : void 0;
+			if (!typeChanges || typeChanges.size === 0) return client.updateTailorDBType({
+				workspaceId: create$1.request.workspaceId,
+				namespaceName: create$1.request.namespaceName,
+				tailordbType: create$1.request.tailordbType
+			});
+			const clonedRequest = structuredClone(create$1.request);
+			if (clonedRequest.tailordbType?.schema?.fields) applyPreMigrationFieldAdjustments(clonedRequest.tailordbType.schema.fields, typeChanges);
+			return client.updateTailorDBType({
+				workspaceId: create$1.request.workspaceId,
+				namespaceName: create$1.request.namespaceName,
+				tailordbType: clonedRequest.tailordbType
+			});
+		}),
+		...changeSet.type.updates.filter((update) => {
+			const typeName = update.request.tailordbType?.name;
+			return typeName && affectedTypes.has(typeName);
+		}).map((update) => {
+			const typeName = update.request.tailordbType?.name;
+			if (typeName) processedTypes.updated.add(typeName);
+			const typeChanges = typeName ? breakingChanges.get(typeName) : void 0;
+			if (!typeChanges || typeChanges.size === 0) return client.updateTailorDBType(update.request);
+			const clonedRequest = structuredClone(update.request);
+			if (clonedRequest.tailordbType?.schema?.fields) applyPreMigrationFieldAdjustments(clonedRequest.tailordbType.schema.fields, typeChanges);
+			return client.updateTailorDBType(clonedRequest);
+		})
+	]);
+	if (!processedTypes.gqlPermissionsProcessed.has(migration.namespace)) {
+		const gqlPermissionCreatesForNamespace = changeSet.gqlPermission.creates.filter((create$1) => create$1.request.namespaceName === migration.namespace);
+		const gqlPermissionUpdatesForNamespace = changeSet.gqlPermission.updates.filter((update) => update.request.namespaceName === migration.namespace);
+		const gqlPermissionTypeNames = new Set(gqlPermissionCreatesForNamespace.map((create$1) => create$1.name));
+		const missingTypeCreates = changeSet.type.creates.filter((create$1) => {
+			const typeName = create$1.request.tailordbType?.name;
+			return create$1.request.namespaceName === migration.namespace && typeName && gqlPermissionTypeNames.has(typeName) && !processedTypes.created.has(typeName);
+		});
+		if (missingTypeCreates.length > 0) await Promise.all(missingTypeCreates.map((create$1) => {
+			const typeName = create$1.request.tailordbType?.name;
+			if (typeName) processedTypes.created.add(typeName);
+			return client.createTailorDBType(create$1.request);
+		}));
+		processedTypes.gqlPermissionsProcessed.add(migration.namespace);
+		await Promise.all([...gqlPermissionCreatesForNamespace.map((create$1) => client.createTailorDBGQLPermission(create$1.request)), ...gqlPermissionUpdatesForNamespace.map((update) => client.updateTailorDBGQLPermission(update.request))]);
 	}
 }
 /**
@@ -8090,23 +9244,9 @@ async function planTailorDB(context) {
 		tailordbs.push(tailordb);
 	}
 	const executors = forRemoval ? [] : Object.values(await application.executorService?.loadExecutors() ?? {});
-	let filteredTypesByNamespace;
-	let skipSchemaCheck = false;
-	if (!forRemoval) {
-		const maxVersionEnv = process.env.TAILOR_INTERNAL_APPLY_MIGRATION_VERSION;
-		if (maxVersionEnv) {
-			const maxVersion = parseInt(maxVersionEnv, 10);
-			if (!Number.isInteger(maxVersion)) throw new Error(`Invalid TAILOR_INTERNAL_APPLY_MIGRATION_VERSION: "${maxVersionEnv}". Must be a valid integer.`);
-			logger.info(`Using schema reconstructed up to migration version ${styles.bold(formatMigrationNumber(maxVersion))}`);
-			logger.info("Schema check will be skipped (local types are ahead of target version)", { mode: "plain" });
-			logger.newline();
-			skipSchemaCheck = true;
-			filteredTypesByNamespace = await buildFilteredTypesForVersion(maxVersion, application, config);
-		}
-	}
 	const { changeSet: serviceChangeSet, conflicts, unmanaged, resourceOwners } = await planServices(client, workspaceId, application.name, tailordbs);
 	const deletedServices = serviceChangeSet.deletes.map((del) => del.name);
-	const typeChangeSet = await planTypes(client, workspaceId, tailordbs, executors, deletedServices, filteredTypesByNamespace);
+	const typeChangeSet = await planTypes(client, workspaceId, tailordbs, executors, deletedServices);
 	const gqlPermissionChangeSet = await planGqlPermissions(client, workspaceId, tailordbs, deletedServices);
 	serviceChangeSet.print();
 	typeChangeSet.print();
@@ -8124,7 +9264,7 @@ async function planTailorDB(context) {
 			workspaceId,
 			application,
 			config,
-			noSchemaCheck: skipSchemaCheck || (noSchemaCheck ?? false)
+			noSchemaCheck: noSchemaCheck ?? false
 		}
 	};
 }
@@ -8919,17 +10059,59 @@ async function loadWorkflowScripts() {
 * @returns Promise that resolves when apply completes
 */
 async function apply(options) {
-	const { config } = await loadConfig(options?.configPath);
+	const { config, plugins } = await loadConfig(options?.configPath);
 	const dryRun = options?.dryRun ?? false;
 	const yes = options?.yes ?? false;
 	const buildOnly = options?.buildOnly ?? process.env.TAILOR_PLATFORM_SDK_BUILD_ONLY === "true";
-	await generateUserTypes(config, config.path);
-	const application = defineApplication(config);
+	let pluginManager;
+	if (plugins.length > 0) pluginManager = new PluginManager(plugins);
+	await generateUserTypes({
+		config,
+		configPath: config.path,
+		plugins
+	});
+	const application = defineApplication({
+		config,
+		pluginManager
+	});
 	let workflowResult;
 	if (application.workflowConfig) workflowResult = await loadAndCollectJobs(application.workflowConfig);
 	const triggerContext = await buildTriggerContext(application.workflowConfig);
+	let tailordbTypesLoaded = false;
+	let pluginExecutorFiles = [];
+	if (application.tailorDBServices.length > 0) {
+		for (const tailordb of application.tailorDBServices) {
+			await tailordb.loadTypes();
+			await tailordb.processNamespacePlugins();
+		}
+		tailordbTypesLoaded = true;
+	}
+	const pluginOutputDir = path.join(getDistDir(), "plugin");
+	const typeGenerationResult = generatePluginTypeFiles(pluginManager?.getPluginGeneratedTypes() ?? [], pluginOutputDir);
+	const sourceTypeInfoMap = /* @__PURE__ */ new Map();
+	for (const db$1 of application.tailorDBServices) {
+		const typeSourceInfo = db$1.getTypeSourceInfo();
+		for (const [typeName, sourceInfo] of Object.entries(typeSourceInfo)) if (sourceInfo.filePath) sourceTypeInfoMap.set(typeName, {
+			filePath: sourceInfo.filePath,
+			exportName: sourceInfo.exportName
+		});
+	}
+	const generatedExecutorFiles = generatePluginExecutorFiles(pluginManager?.getPluginGeneratedExecutorsWithImportPath() ?? [], pluginOutputDir, typeGenerationResult, sourceTypeInfoMap, config.path);
+	const pluginExecutorFileSet = new Set(generatedExecutorFiles);
+	const legacyPluginExecutorDir = path.join(getDistDir(), "plugin-executors");
+	if (fs$2.existsSync(legacyPluginExecutorDir)) {
+		const legacyFiles = fs$2.readdirSync(legacyPluginExecutorDir).filter((f) => f.endsWith(".ts")).map((f) => path.join(legacyPluginExecutorDir, f));
+		for (const file of legacyFiles) pluginExecutorFileSet.add(file);
+	}
+	pluginExecutorFiles = Array.from(pluginExecutorFileSet);
+	const executorService = application.executorService ?? (pluginExecutorFiles.length > 0 ? createExecutorService({
+		config: { files: [] },
+		pluginManager
+	}) : void 0);
+	const mutableApplication = application;
+	mutableApplication.executorService = executorService;
 	for (const app$1 of application.applications) for (const pipeline$1 of app$1.resolverServices) await buildPipeline(pipeline$1.namespace, pipeline$1.config, triggerContext);
-	if (application.executorService) await buildExecutor(application.executorService.config, triggerContext);
+	if (executorService) await buildExecutor(executorService.config, triggerContext, pluginExecutorFiles);
 	let workflowBuildResult;
 	if (workflowResult && workflowResult.jobs.length > 0) {
 		const mainJobNames = workflowResult.workflowSources.map((ws) => ws.workflow.mainJob.name);
@@ -8944,9 +10126,15 @@ async function apply(options) {
 		workspaceId: options?.workspaceId,
 		profile: options?.profile
 	});
-	for (const tailordb of application.tailorDBServices) await tailordb.loadTypes();
+	if (!tailordbTypesLoaded) for (const tailordb of application.tailorDBServices) {
+		await tailordb.loadTypes();
+		await tailordb.processNamespacePlugins();
+	}
 	for (const pipeline$1 of application.resolverServices) await pipeline$1.loadResolvers();
-	if (application.executorService) await application.executorService.loadExecutors();
+	if (executorService) {
+		await executorService.loadExecutors();
+		if (pluginExecutorFiles.length > 0) await executorService.loadPluginExecutorFiles(pluginExecutorFiles);
+	}
 	if (workflowResult) printLoadedWorkflows(workflowResult);
 	logger.newline();
 	const ctx = {
@@ -8993,6 +10181,14 @@ async function apply(options) {
 		resourceType: "StaticWebsite",
 		resourceName: del.name
 	});
+	for (const del of auth.changeSet.oauth2Client.deletes) importantDeletions.push({
+		resourceType: "OAuth2 client",
+		resourceName: del.name
+	});
+	for (const replace of auth.changeSet.oauth2Client.replaces) importantDeletions.push({
+		resourceType: "OAuth2 client (client type change)",
+		resourceName: replace.name
+	});
 	await confirmImportantResourceDeletion(importantDeletions, yes);
 	const resourceOwners = new Set([
 		...tailorDB.resourceOwners,
@@ -9015,10 +10211,10 @@ async function apply(options) {
 		logger.info("Dry run enabled. No changes applied.");
 		return;
 	}
-	await applyTailorDB(client, tailorDB, "create-update");
 	await applyStaticWebsite(client, staticWebsite, "create-update");
 	await applyIdP(client, idp, "create-update");
 	await applyAuth(client, auth, "create-update");
+	await applyTailorDB(client, tailorDB, "create-update");
 	await applyPipeline(client, pipeline, "create-update");
 	await applyPipeline(client, pipeline, "delete-resources");
 	await applyAuth(client, auth, "delete-resources");
@@ -9039,8 +10235,12 @@ async function apply(options) {
 async function buildPipeline(namespace, config, triggerContext) {
 	await bundleResolvers(namespace, config, triggerContext);
 }
-async function buildExecutor(config, triggerContext) {
-	await bundleExecutors(config, triggerContext);
+async function buildExecutor(config, triggerContext, additionalFiles) {
+	await bundleExecutors({
+		config,
+		triggerContext,
+		additionalFiles
+	});
 }
 async function buildWorkflow(collectedJobs, mainJobNames, env, triggerContext) {
 	return bundleWorkflowJobs(collectedJobs, mainJobNames, env, triggerContext);
@@ -11154,11 +12354,17 @@ function createDependencyWatcher(options = {}) {
 * Creates a generation manager.
 * @param config - Application configuration
 * @param generators - List of generators
+* @param plugins - List of plugins
 * @param configPath - Path to the configuration file
 * @returns GenerationManager instance
 */
-function createGenerationManager(config, generators = [], configPath) {
-	const application = defineApplication(config);
+function createGenerationManager(config, generators = [], plugins = [], configPath) {
+	let pluginManager;
+	if (plugins.length > 0) pluginManager = new PluginManager(plugins);
+	const application = defineApplication({
+		config,
+		pluginManager
+	});
 	const baseDir = path.join(getDistDir(), "generated");
 	fs$2.mkdirSync(baseDir, { recursive: true });
 	const services = {
@@ -11208,7 +12414,8 @@ function createGenerationManager(config, generators = [], configPath) {
 				results.tailordbResults[namespace][typeName] = await processType({
 					type,
 					namespace,
-					source: typeInfo.sourceInfo[typeName]
+					source: typeInfo.sourceInfo[typeName],
+					plugins: typeInfo.pluginAttachments.get(typeName) ?? []
 				});
 			} catch (error) {
 				logger.error(`Error processing type ${styles.bold(typeName)} in ${namespace} with generator ${gen.id}`);
@@ -11381,13 +12588,15 @@ function createGenerationManager(config, generators = [], configPath) {
 			logger.newline();
 			logger.log(`Generation for application: ${styles.highlight(application.config.name)}`);
 			const app = application;
-			for (const db of app.tailorDBServices) {
-				const namespace = db.namespace;
+			for (const db$1 of app.tailorDBServices) {
+				const namespace = db$1.namespace;
 				try {
-					await db.loadTypes();
+					await db$1.loadTypes();
+					await db$1.processNamespacePlugins();
 					services.tailordb[namespace] = {
-						types: db.getTypes(),
-						sourceInfo: db.getTypeSourceInfo()
+						types: db$1.getTypes(),
+						sourceInfo: db$1.getTypeSourceInfo(),
+						pluginAttachments: db$1.getPluginAttachments()
 					};
 				} catch (error) {
 					logger.error(`Error loading types for TailorDB service ${styles.bold(namespace)}`);
@@ -11395,8 +12604,23 @@ function createGenerationManager(config, generators = [], configPath) {
 					if (!watch$1) throw error;
 				}
 			}
+			const pluginOutputDir = path.join(getDistDir(), "plugin");
+			const typeGenerationResult = generatePluginTypeFiles(pluginManager?.getPluginGeneratedTypes() ?? [], pluginOutputDir);
+			const sourceTypeInfoMap = /* @__PURE__ */ new Map();
+			for (const db$1 of app.tailorDBServices) {
+				const typeSourceInfo = db$1.getTypeSourceInfo();
+				for (const [typeName, sourceInfo] of Object.entries(typeSourceInfo)) if (sourceInfo.filePath) sourceTypeInfoMap.set(typeName, {
+					filePath: sourceInfo.filePath,
+					exportName: sourceInfo.exportName
+				});
+			}
+			const generatedExecutorFiles = generatePluginExecutorFiles(pluginManager?.getPluginGeneratedExecutorsWithImportPath() ?? [], pluginOutputDir, typeGenerationResult, sourceTypeInfoMap, configPath);
+			const executorService = application.executorService ?? (generatedExecutorFiles.length > 0 ? createExecutorService({
+				config: { files: [] },
+				pluginManager
+			}) : void 0);
 			if (app.authService) await app.authService.resolveNamespaces();
-			if (app.tailorDBServices.length > 0) logger.newline();
+			if (app.tailorDBServices.length > 0 || generatedExecutorFiles.length > 0) logger.newline();
 			const tailordbOnlyGens = generators.filter((g) => onlyHas(g, "tailordb"));
 			if (tailordbOnlyGens.length > 0) {
 				await runGenerators(tailordbOnlyGens, watch$1);
@@ -11421,9 +12645,11 @@ function createGenerationManager(config, generators = [], configPath) {
 				await runGenerators(nonExecutorGens, watch$1);
 				logger.newline();
 			}
-			const executors = await application.executorService?.loadExecutors();
-			Object.entries(executors ?? {}).forEach(([filePath, executor]) => {
-				services.executor[filePath] = executor;
+			await executorService?.loadExecutors();
+			if (generatedExecutorFiles.length > 0) await executorService?.loadPluginExecutorFiles(generatedExecutorFiles);
+			const allExecutors = executorService?.getExecutors() ?? {};
+			Object.entries(allExecutors).forEach(([key, executor]) => {
+				services.executor[key] = executor;
 			});
 			const executorGens = generators.filter((g) => hasAll(g, "executor"));
 			if (executorGens.length > 0) {
@@ -11438,9 +12664,9 @@ function createGenerationManager(config, generators = [], configPath) {
 			});
 			if (configPath) await watcher.addWatchGroup("Config", [configPath]);
 			const app = application;
-			for (const db of app.tailorDBServices) {
-				const dbNamespace = db.namespace;
-				await watcher?.addWatchGroup(`TailorDB/${dbNamespace}`, db.config.files);
+			for (const db$1 of app.tailorDBServices) {
+				const dbNamespace = db$1.namespace;
+				await watcher?.addWatchGroup(`TailorDB/${dbNamespace}`, db$1.config.files);
 			}
 			for (const resolverService of app.resolverServices) {
 				const resolverNamespace = resolverService.namespace;
@@ -11456,10 +12682,14 @@ function createGenerationManager(config, generators = [], configPath) {
 * @returns Promise that resolves when generation (and watch, if enabled) completes
 */
 async function generate$1(options) {
-	const { config, generators } = await loadConfig(options?.configPath);
+	const { config, generators, plugins } = await loadConfig(options?.configPath);
 	const watch$1 = options?.watch ?? false;
-	await generateUserTypes(config, config.path);
-	const manager = createGenerationManager(config, generators, config.path);
+	await generateUserTypes({
+		config,
+		configPath: config.path,
+		plugins
+	});
+	const manager = createGenerationManager(config, generators, plugins, config.path);
 	await manager.generate(watch$1);
 	if (watch$1) await manager.watch();
 }
@@ -11779,7 +13009,7 @@ async function loadOptions$9(options) {
 	return {
 		client,
 		workspaceId,
-		application: defineApplication(config),
+		application: defineApplication({ config }),
 		config
 	};
 }
@@ -12008,7 +13238,7 @@ function generateDbTypesFromSnapshot(snapshot, diff) {
 		" * DO NOT EDIT - This file is auto-generated by the migration system.",
 		" */",
 		"",
-		`import { ${imports.join(", ")} } from "kysely";`,
+		`import { ${imports.join(", ")} } from "@tailor-platform/sdk/kysely";`,
 		"",
 		...utilityTypeDeclarations,
 		"",
@@ -12033,7 +13263,7 @@ function generateEmptyDbTypes(namespace) {
 		" * DO NOT EDIT - This file is auto-generated by the migration system.",
 		" */",
 		"",
-		"import { type Transaction as KyselyTransaction } from \"kysely\";",
+		"import { type Transaction as KyselyTransaction } from \"@tailor-platform/sdk/kysely\";",
 		"",
 		"// eslint-disable-next-line @typescript-eslint/no-empty-object-type",
 		"interface Database {}",
@@ -12420,7 +13650,7 @@ async function handleInitOption(namespaces, skipConfirmation) {
 */
 async function generate(options) {
 	logBetaWarning("tailordb migration");
-	const { config } = await loadConfig(options.configPath);
+	const { config, plugins } = await loadConfig(options.configPath);
 	const namespacesWithMigrations = getNamespacesWithMigrations(config, path.dirname(config.path));
 	if (namespacesWithMigrations.length === 0) {
 		logger.warn("No TailorDB namespaces with migrations config found.");
@@ -12428,8 +13658,13 @@ async function generate(options) {
 		return;
 	}
 	if (options.init) await handleInitOption(namespacesWithMigrations, options.yes);
-	const { defineApplication: defineApplication$1 } = await import("./application-a12-7TT3.mjs");
-	const application = defineApplication$1(config);
+	let pluginManager;
+	if (plugins.length > 0) pluginManager = new PluginManager(plugins);
+	const { defineApplication: defineApplication$1 } = await import("./application-DM4zTgXU.mjs");
+	const application = defineApplication$1({
+		config,
+		pluginManager
+	});
 	for (const { namespace, migrationsDir } of namespacesWithMigrations) {
 		logger.info(`Processing namespace: ${styles.bold(namespace)}`);
 		assertValidMigrationFiles(migrationsDir, namespace);
@@ -12439,6 +13674,7 @@ async function generate(options) {
 			continue;
 		}
 		await tailordbService.loadTypes();
+		await tailordbService.processNamespacePlugins();
 		const currentSnapshot = createSnapshotFromLocalTypes(tailordbService.getTypes(), namespace);
 		let previousSnapshot = null;
 		try {
@@ -13634,5 +14870,5 @@ const updateCommand = defineCommand({
 });
 
 //#endregion
-export { jobsCommand as $, readPackageJson as $t, generateCommand as A, getNextMigrationNumber as At, getMachineUserToken as B, loadConfig as Bt, resumeCommand as C, compareSnapshots as Ct, truncate as D, getMigrationDirPath as Dt, listWorkflows as E, getLatestMigrationNumber as Et, removeCommand$1 as F, formatMigrationDiff as Ft, generateCommand$1 as G, loadAccessToken as Gt, listCommand$5 as H, apiCall as Ht, listCommand$4 as I, hasChanges as It, triggerCommand as J, writePlatformConfig as Jt, listWebhookExecutors as K, loadWorkspaceId as Kt, listOAuth2Clients as L, getNamespacesWithMigrations as Lt, show as M, loadDiff as Mt, showCommand as N, reconstructSnapshotFromMigrations as Nt, truncateCommand as O, getMigrationFilePath as Ot, remove as P, formatDiffSummary as Pt, getExecutorJob as Q, initOperatorClient as Qt, getCommand$1 as R, trnPrefix as Rt, healthCommand as S, compareLocalTypesWithSnapshot as St, listCommand$3 as T, formatMigrationNumber as Tt, listMachineUsers as U, apiCommand as Ut, tokenCommand as V, getDistDir as Vt, generate$1 as W, fetchLatestToken as Wt, listCommand$6 as X, fetchUserInfo as Xt, triggerExecutor as Y, fetchAll as Yt, listExecutors as Z, initOAuth2Client as Zt, createCommand as _, DB_TYPES_FILE_NAME as _t, listCommand as a, withCommonArgs as an, getWorkflow as at, listCommand$2 as b, MIGRATE_FILE_NAME as bt, inviteUser as c, listWorkflowExecutions as ct, listCommand$1 as d, apply as dt, PATScope as en, listExecutorJobs as et, listWorkspaces as f, applyCommand as ft, deleteWorkspace as g, parseMigrationLabelNumber as gt, deleteCommand as h, MIGRATION_LABEL_KEY as ht, removeUser as i, jsonArgs as in, getCommand$2 as it, logBetaWarning as j, isValidMigrationNumber as jt, generate as k, getMigrationFiles as kt, restoreCommand as l, getCommand$3 as lt, getWorkspace as m, waitForExecution$1 as mt, updateUser as n, confirmationArgs as nn, startCommand as nt, listUsers as o, workspaceArgs as on, executionsCommand as ot, getCommand as p, executeScript as pt, webhookCommand as q, readPlatformConfig as qt, removeCommand as r, deploymentArgs as rn, startWorkflow as rt, inviteCommand as s, getWorkflowExecution as st, updateCommand as t, commonArgs as tn, watchExecutorJob as tt, restoreWorkspace as u, getExecutor as ut, createWorkspace as v, DIFF_FILE_NAME as vt, resumeWorkflow as w, createSnapshotFromLocalTypes as wt, getAppHealth as x, SCHEMA_FILE_NAME as xt, listApps as y, INITIAL_SCHEMA_NUMBER as yt, getOAuth2Client as z, generateUserTypes as zt };
-//# sourceMappingURL=update-D0muqqOP.mjs.map
+export { jobsCommand as $, initOperatorClient as $t, generateCommand as A, getMigrationFiles as At, getMachineUserToken as B, generateUserTypes as Bt, resumeCommand as C, compareLocalTypesWithSnapshot as Ct, truncate as D, getLatestMigrationNumber as Dt, listWorkflows as E, formatMigrationNumber as Et, removeCommand$1 as F, formatDiffSummary as Ft, generateCommand$1 as G, fetchLatestToken as Gt, listCommand$5 as H, getDistDir as Ht, listCommand$4 as I, formatMigrationDiff as It, triggerCommand as J, readPlatformConfig as Jt, listWebhookExecutors as K, loadAccessToken as Kt, listOAuth2Clients as L, hasChanges as Lt, show as M, isValidMigrationNumber as Mt, showCommand as N, loadDiff as Nt, truncateCommand as O, getMigrationDirPath as Ot, remove as P, reconstructSnapshotFromMigrations as Pt, getExecutorJob as Q, initOAuth2Client as Qt, getCommand$1 as R, getNamespacesWithMigrations as Rt, healthCommand as S, SCHEMA_FILE_NAME as St, listCommand$3 as T, createSnapshotFromLocalTypes as Tt, listMachineUsers as U, apiCall as Ut, tokenCommand as V, loadConfig as Vt, generate$1 as W, apiCommand as Wt, listCommand$6 as X, fetchAll as Xt, triggerExecutor as Y, writePlatformConfig as Yt, listExecutors as Z, fetchUserInfo as Zt, createCommand as _, bundleMigrationScript as _t, listCommand as a, jsonArgs as an, getWorkflow as at, listCommand$2 as b, INITIAL_SCHEMA_NUMBER as bt, inviteUser as c, listWorkflowExecutions as ct, listCommand$1 as d, apply as dt, readPackageJson as en, listExecutorJobs as et, listWorkspaces as f, applyCommand as ft, deleteWorkspace as g, parseMigrationLabelNumber as gt, deleteCommand as h, MIGRATION_LABEL_KEY as ht, removeUser as i, deploymentArgs as in, getCommand$2 as it, logBetaWarning as j, getNextMigrationNumber as jt, generate as k, getMigrationFilePath as kt, restoreCommand as l, getCommand$3 as lt, getWorkspace as m, waitForExecution$1 as mt, updateUser as n, commonArgs as nn, startCommand as nt, listUsers as o, withCommonArgs as on, executionsCommand as ot, getCommand as p, executeScript as pt, webhookCommand as q, loadWorkspaceId as qt, removeCommand as r, confirmationArgs as rn, startWorkflow as rt, inviteCommand as s, workspaceArgs as sn, getWorkflowExecution as st, updateCommand as t, PATScope as tn, watchExecutorJob as tt, restoreWorkspace as u, getExecutor as ut, createWorkspace as v, DB_TYPES_FILE_NAME as vt, resumeWorkflow as w, compareSnapshots as wt, getAppHealth as x, MIGRATE_FILE_NAME as xt, listApps as y, DIFF_FILE_NAME as yt, getOAuth2Client as z, trnPrefix as zt };
+//# sourceMappingURL=update-B_W-UQnS.mjs.map