@tailor-platform/sdk 1.17.1 → 1.19.0

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

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