@tailor-platform/sdk 1.17.1 → 1.18.0

package/docs/plugin/custom.md

@@ -24,112 +24,255 @@ This is required so that generators can use plugin-generated TailorDB types via
 
 ```typescript
 interface Plugin<TypeConfig = unknown, PluginConfig = unknown> {
-  /** Unique identifier for the plugin (e.g., "@my-company/soft-delete") */
   readonly id: string;
-
-  /** Human-readable description */
   readonly description: string;
-
-  /** Import path for generated code to reference */
-  readonly importPath: string;
-
-  /** Controls whether per-type config is required when attaching via .plugin() */
+  readonly importPath?: string;
   readonly typeConfigRequired?: boolean | ((pluginConfig?: PluginConfig) => boolean);
-
-  /** Plugin-level config passed via definePlugins() */
   readonly pluginConfig?: PluginConfig;
 
-  /** Process a type with this plugin attached */
-  processType?(
+  // Definition-time hooks
+  onTypeLoaded?(
     context: PluginProcessContext<TypeConfig, PluginConfig>,
   ): TypePluginOutput | Promise<TypePluginOutput>;
-
-  /** Process a namespace (plugins without a source type) */
-  processNamespace?(
+  onNamespaceLoaded?(
     context: PluginNamespaceProcessContext<PluginConfig>,
   ): PluginOutput | Promise<PluginOutput>;
+
+  // Generation-time hooks
+  onTailorDBReady?(
+    context: TailorDBReadyContext<PluginConfig>,
+  ): GeneratorResult | Promise<GeneratorResult>;
+  onResolverReady?(
+    context: ResolverReadyContext<PluginConfig>,
+  ): GeneratorResult | Promise<GeneratorResult>;
+  onExecutorReady?(
+    context: ExecutorReadyContext<PluginConfig>,
+  ): GeneratorResult | Promise<GeneratorResult>;
 }
 ```
 
-Notes:
+| Property             | Required                         | Description                                                                                      |
+| -------------------- | -------------------------------- | ------------------------------------------------------------------------------------------------ |
+| `id`                 | Yes                              | Unique plugin identifier (e.g., `"@my-company/soft-delete"`)                                     |
+| `description`        | Yes                              | Human-readable description                                                                       |
+| `importPath`         | When using definition-time hooks | Path resolvable from `tailor.config.ts` directory. Used for import statements in generated code. |
+| `typeConfigRequired` | No                               | Whether per-type config is required when attaching via `.plugin()`. Default: optional.           |
+| `pluginConfig`       | No                               | Plugin-level config passed via `definePlugins()`. Set via factory function.                      |
 
-- `importPath` should be resolvable from the directory containing `tailor.config.ts`. Code generators use it to import plugin APIs such as `getGeneratedType` and executor modules.
-- If you want to attach a plugin via `.plugin()`, implement the `processType` method.
-- Namespace-only plugins implement `processNamespace` instead.
-- `pluginConfig` stores the plugin-level config so it can be read later during processing. Set it on the plugin object (e.g., via a factory function) before passing to `definePlugins()`.
-- `resolve` should return a dynamic import; relative specifiers are resolved from the plugin module.
-- Per-type config is optional by default. Use `typeConfigRequired: true` to make it mandatory.
-- To toggle optional/required based on plugin config, provide a function for `typeConfigRequired`.
-- Use TypeScript type parameters (`TypeConfig`, `PluginConfig`) to get type-safe config in your `processType` and `processNamespace` methods.
+## Hook Reference
 
-## PluginProcessContext
+### onTypeLoaded
 
-Context passed to the `processType` method:
+**Trigger**: Called once for each TailorDB type that has `.plugin({ pluginId: config })` attached.
 
-```typescript
-interface PluginProcessContext<TypeConfig = unknown, PluginConfig = unknown> {
-  /** The TailorDB type being processed */
-  type: TailorAnyDBType;
+**Context** (`PluginProcessContext`):
 
-  /** Per-type configuration from .plugin({ pluginId: typeConfig }) */
-  typeConfig: TypeConfig;
+| Field          | Type              | Description                                |
+| -------------- | ----------------- | ------------------------------------------ |
+| `type`         | `TailorAnyDBType` | The TailorDB type being processed          |
+| `typeConfig`   | `TypeConfig`      | Per-type config from `.plugin()`           |
+| `pluginConfig` | `PluginConfig`    | Plugin-level config from `definePlugins()` |
+| `namespace`    | `string`          | Namespace of the TailorDB type             |
 
-  /** Plugin-level configuration from definePlugins() */
-  pluginConfig: PluginConfig;
+**Returns** (`TypePluginOutput`):
 
-  /** Namespace of the TailorDB type */
-  namespace: string;
-}
-```
+| Field       | Type                                            | Description                                           |
+| ----------- | ----------------------------------------------- | ----------------------------------------------------- |
+| `types`     | `Record<string, TailorAnyDBType>`               | Additional TailorDB types to generate (keyed by kind) |
+| `resolvers` | `PluginGeneratedResolver[]`                     | Additional resolvers to generate                      |
+| `executors` | `PluginGeneratedExecutor[]`                     | Additional executors to generate                      |
+| `extends`   | `{ fields?: Record<string, TailorAnyDBField> }` | Fields to add to the source type                      |
 
-## PluginNamespaceProcessContext
+**Use cases**:
 
-Context passed to the `processNamespace` method:
+- Generate derived types (e.g., archive tables, history tables) from user-defined types
+- Add fields to existing types (e.g., `deletedAt` for soft delete)
+- Generate executors triggered by record events on the source type
 
 ```typescript
-interface PluginNamespaceProcessContext<PluginConfig = unknown> {
-  /** Plugin-level configuration from definePlugins() */
-  pluginConfig: PluginConfig;
+onTypeLoaded(context) {
+  const { type, typeConfig, namespace } = context;
+  return {
+    types: { archive: db.type(`Deleted_${type.name}`, { ... }) },
+    extends: { fields: { deletedAt: db.datetime({ optional: true }) } },
+    executors: [{ name: `${type.name}-on-delete`, resolve: async () => await import("./on-delete"), context: { sourceType: type, namespace } }],
+  };
+},
+```
 
-  /** Target namespace for generated types */
-  namespace: string;
-}
+### onNamespaceLoaded
+
+**Trigger**: Called once per namespace for plugins that do not require a source type.
+
+**Context** (`PluginNamespaceProcessContext`):
+
+| Field          | Type           | Description                                |
+| -------------- | -------------- | ------------------------------------------ |
+| `pluginConfig` | `PluginConfig` | Plugin-level config from `definePlugins()` |
+| `namespace`    | `string`       | Target namespace                           |
+
+**Returns** (`PluginOutput`):
+
+Same as `TypePluginOutput` but without `extends` (namespace plugins cannot extend a source type).
+
+**Use cases**:
+
+- Generate types that don't derive from a specific user type (e.g., audit log, settings table)
+
+```typescript
+onNamespaceLoaded(context) {
+  return {
+    types: { auditLog: db.type("AuditLog", { action: db.string(), ... }) },
+  };
+},
 ```
 
-## Output Types
+### onTailorDBReady
+
+**Trigger**: Called once after all TailorDB types are loaded and auth is resolved.
+
+**Context** (`TailorDBReadyContext`):
+
+| Field          | Type                      | Description                                                    |
+| -------------- | ------------------------- | -------------------------------------------------------------- |
+| `tailordb`     | `TailorDBNamespaceData[]` | All namespaces with types, source info, and plugin attachments |
+| `auth`         | `GeneratorAuthInput?`     | Auth configuration (machine users, OAuth2 clients, etc.)       |
+| `baseDir`      | `string`                  | Output directory for generated files                           |
+| `configPath`   | `string`                  | Path to `tailor.config.ts`                                     |
+| `pluginConfig` | `PluginConfig`            | Plugin-level config from `definePlugins()`                     |
 
-### PluginOutput (base)
+`TailorDBNamespaceData` contains:
 
-Base output used by both `processType` and `processNamespace`:
+| Field               | Type                                       | Description                          |
+| ------------------- | ------------------------------------------ | ------------------------------------ |
+| `namespace`         | `string`                                   | Namespace name                       |
+| `types`             | `Record<string, TailorDBType>`             | All finalized types in the namespace |
+| `sourceInfo`        | `ReadonlyMap<string, TypeSourceInfoEntry>` | Source file info for each type       |
+| `pluginAttachments` | `ReadonlyMap<string, PluginAttachment[]>`  | Plugin configs attached to each type |
+
+**Returns** (`GeneratorResult`):
+
+| Field    | Type                                                   | Description              |
+| -------- | ------------------------------------------------------ | ------------------------ |
+| `files`  | `Array<{ path, content, skipIfExists?, executable? }>` | Files to write to disk   |
+| `errors` | `string[]?`                                            | Error messages to report |
+
+**Use cases**:
+
+- Generate type definitions (e.g., Kysely types, enum constants)
+- Generate seed data scaffolding from type schemas
+- Generate type lists or metadata files
 
 ```typescript
-interface PluginOutput {
-  /** Additional TailorDB types to generate */
-  types?: Record<string, TailorAnyDBType>;
+onTailorDBReady(ctx) {
+  const allTypes = ctx.tailordb.flatMap((ns) =>
+    Object.values(ns.types).map((t) => t.name),
+  );
+  return {
+    files: [{ path: `${ctx.baseDir}/types.ts`, content: `export const types = ${JSON.stringify(allTypes)};\n` }],
+  };
+},
+```
 
-  /** Additional resolvers to generate */
-  resolvers?: PluginGeneratedResolver[];
+### onResolverReady
 
-  /** Additional executors to generate */
-  executors?: PluginGeneratedExecutor[];
-}
+**Trigger**: Called once after all resolvers are loaded, for plugins that do not implement `onExecutorReady`.
+
+**Context** (`ResolverReadyContext`):
+
+All fields from `TailorDBReadyContext`, plus:
+
+| Field       | Type                      | Description                         |
+| ----------- | ------------------------- | ----------------------------------- |
+| `resolvers` | `ResolverNamespaceData[]` | All namespaces with their resolvers |
+
+`ResolverNamespaceData` contains:
+
+| Field       | Type                       | Description                    |
+| ----------- | -------------------------- | ------------------------------ |
+| `namespace` | `string`                   | Namespace name                 |
+| `resolvers` | `Record<string, Resolver>` | All resolvers in the namespace |
+
+**Returns**: `GeneratorResult` (same as `onTailorDBReady`)
+
+**Use cases**:
+
+- Generate API client code from resolver definitions
+- Generate documentation that includes resolver endpoints
+
+```typescript
+onResolverReady(ctx) {
+  const resolverNames = ctx.resolvers.flatMap((ns) =>
+    Object.values(ns.resolvers).map((r) => r.name),
+  );
+  return {
+    files: [{ path: `${ctx.baseDir}/api.ts`, content: generateApiClient(resolverNames) }],
+  };
+},
 ```
 
-### TypePluginOutput
+### onExecutorReady
+
+**Trigger**: Called once after all executors are loaded.
+
+**Context** (`ExecutorReadyContext`):
+
+All fields from `ResolverReadyContext`, plus:
+
+| Field       | Type                       | Description                            |
+| ----------- | -------------------------- | -------------------------------------- |
+| `executors` | `Record<string, Executor>` | All executors (keyed by executor name) |
 
-Return value from `processType`. Extends `PluginOutput` with the ability to add fields to the source type:
+**Returns**: `GeneratorResult` (same as `onTailorDBReady`)
+
+**Use cases**:
+
+- Generate dashboards or reports that need the full application topology
+- Generate configuration files that reference all services
 
 ```typescript
-interface TypePluginOutput extends PluginOutput {
-  /** Extensions to apply to the source type */
-  extends?: {
-    /** Fields to add to the source type */
-    fields?: Record<string, TailorAnyDBField>;
+onExecutorReady(ctx) {
+  const summary = {
+    types: ctx.tailordb.flatMap((ns) => Object.keys(ns.types)),
+    resolvers: ctx.resolvers.flatMap((ns) => Object.keys(ns.resolvers)),
+    executors: Object.keys(ctx.executors),
   };
-}
+  return {
+    files: [{ path: `${ctx.baseDir}/app-summary.json`, content: JSON.stringify(summary, null, 2) }],
+  };
+},
 ```
 
-`processNamespace` returns `PluginOutput` directly (namespace plugins cannot extend a source type).
+## Hook Scheduling Rules
+
+Each generation-time hook runs at its own pipeline phase, regardless of what other hooks the same plugin implements:
+
+| Hook              | Runs after       | Data provided                                   |
+| ----------------- | ---------------- | ----------------------------------------------- |
+| `onTailorDBReady` | TailorDB loaded  | `tailordb` + `auth`                             |
+| `onResolverReady` | Resolvers loaded | `tailordb` + `resolvers` + `auth`               |
+| `onExecutorReady` | Executors loaded | `tailordb` + `resolvers` + `executors` + `auth` |
+
+A plugin implementing multiple hooks (e.g., both `onTailorDBReady` and `onResolverReady`) will have each hook called at its natural phase. This ensures that files generated by `onTailorDBReady` are available when resolvers are loaded, before `onResolverReady` runs.
+
+## Import Types
+
+All context and result types are exported from `@tailor-platform/sdk`:
+
+```typescript
+import type {
+  Plugin,
+  PluginProcessContext,
+  TypePluginOutput,
+  PluginOutput,
+  TailorDBReadyContext,
+  ResolverReadyContext,
+  ExecutorReadyContext,
+  TailorDBNamespaceData,
+  ResolverNamespaceData,
+  GeneratorResult,
+} from "@tailor-platform/sdk";
+```
 
 ## getGeneratedType Helper
 
@@ -142,13 +285,16 @@ import { customer } from "./tailordb/customer";
 
 const configPath = join(import.meta.dirname, "./tailor.config.ts");
 
-// Get the generated type by config path, plugin ID, source type, and kind
+// Type-attached plugin
 const DeletedCustomer = await getGeneratedType(
   configPath,
   "@example/soft-delete",
   customer,
   "archive",
 );
+
+// Namespace plugin (pass null as sourceType)
+const AuditLog = await getGeneratedType(configPath, "@example/audit-log", null, "auditLog");
 ```
 
 **Parameters:**
@@ -163,36 +309,15 @@ const DeletedCustomer = await getGeneratedType(
 1. Loads and caches the config from the given path
 2. Finds the plugin by ID from `definePlugins()` exports
 3. Auto-resolves the namespace from config
-4. Calls the plugin's `processType()` or `processNamespace()` method
+4. Calls the plugin's `onTypeLoaded()` or `onNamespaceLoaded()` method
 5. Caches the result to avoid redundant processing
 6. Returns the generated type matching the specified kind
 
-### Example Usage
+## Examples
 
-```typescript
-import { join } from "node:path";
-import { getGeneratedType } from "@tailor-platform/sdk/plugin";
-import { customer } from "./tailordb/customer";
+### Definition-time Plugin (Soft Delete)
 
-const configPath = join(import.meta.dirname, "./tailor.config.ts");
-
-// Type-attached plugin
-const DeletedCustomer = await getGeneratedType(
-  configPath,
-  "@example/soft-delete",
-  customer,
-  "archive",
-);
-
-// Namespace plugin (pass null as sourceType)
-const AuditLog = await getGeneratedType(configPath, "@example/audit-log", null, "auditLog");
-```
-
-## Example: Soft Delete Plugin
-
-A complete example of a plugin that adds soft delete functionality:
-
-### Plugin Definition
+A plugin that adds soft delete functionality via `onTypeLoaded`:
 
 ```typescript
 // plugins/soft-delete/plugin.ts
@@ -252,7 +377,6 @@ function processSoftDelete(
   };
 }
 
-// Factory function for plugins with plugin-level config
 function createSoftDeletePlugin(
   pluginConfig?: SoftDeletePluginConfig,
 ): Plugin<SoftDeleteConfig, SoftDeletePluginConfig> {
@@ -262,15 +386,14 @@ function createSoftDeletePlugin(
     importPath: "./plugins/soft-delete",
     pluginConfig,
     typeConfigRequired: (config) => config?.requireTypeConfig === true,
-    processType: processSoftDelete,
+    onTypeLoaded: processSoftDelete,
   };
 }
 
-// Default export is required for getGeneratedType() to work
 export default createSoftDeletePlugin();
 ```
 
-### Executor with Context
+#### Executor with Context
 
 ```typescript
 // plugins/soft-delete/executors/on-delete.ts
@@ -311,14 +434,13 @@ export default withPluginContext((ctx: SoftDeleteContext) => {
 });
 ```
 
-### Usage
+#### Usage
 
 ```typescript
 // tailor.config.ts
 import { definePlugins } from "@tailor-platform/sdk";
 import softDeletePlugin from "./plugins/soft-delete";
 
-// Use a factory function to pass plugin-level config
 export const plugins = definePlugins(
   softDeletePlugin({
     archiveTablePrefix: "Deleted_",
@@ -339,26 +461,64 @@ export const customer = db
   });
 ```
 
-If your plugin uses `typeConfigRequired` as a function, you can toggle whether per-type config
-is required via `pluginConfig`:
+### Generation-only Plugin (Type List)
+
+A plugin that only uses `onTailorDBReady` to generate output files:
 
 ```typescript
-export const plugins = definePlugins(
-  softDeletePlugin({
-    archiveTablePrefix: "Deleted_",
-    requireTypeConfig: true,
-  }),
-);
+import type { Plugin, GeneratorResult } from "@tailor-platform/sdk";
+
+const typeListPlugin: Plugin = {
+  id: "@example/type-list",
+  description: "Generates a list of all TailorDB type names",
+
+  onTailorDBReady(ctx): GeneratorResult {
+    const allTypes = ctx.tailordb.flatMap((ns) =>
+      Object.entries(ns.types).map(([_, type]) => ({
+        name: type.name,
+        fieldCount: Object.keys(type.fields).length,
+        namespace: ns.namespace,
+      })),
+    );
+    const content = `// Generated type list\nexport const types = ${JSON.stringify(allTypes, null, 2)} as const;\n`;
+    return {
+      files: [{ path: `${ctx.baseDir}/types.ts`, content }],
+    };
+  },
+};
 ```
 
-## Adding Type Safety
+### Hybrid Plugin (Definition + Generation)
+
+A plugin that uses both definition-time and generation-time hooks:
+
+```typescript
+const plugin: Plugin = {
+  id: "@example/hybrid",
+  description: "Generates derived types and produces output files",
+  importPath: "./plugins/hybrid",
+
+  // Definition-time: Generate additional types from attached source types
+  onTypeLoaded(context) {
+    return { types: { derived: createDerivedType(context.type) } };
+  },
+
+  // Generation-time: Generate output files from all finalized types
+  onTailorDBReady(ctx) {
+    const allTypes = ctx.tailordb.flatMap((ns) => Object.values(ns.types).map((t) => t.name));
+    return {
+      files: [{ path: `${ctx.baseDir}/output.ts`, content: generateCode(allTypes) }],
+    };
+  },
+};
+```
 
-Plugin type safety is provided at two levels:
+## Adding Type Safety
 
 ### Plugin-level type safety (TypeConfig / PluginConfig)
 
 Use TypeScript type parameters on `Plugin<TypeConfig, PluginConfig>` to get type-safe config
-in `processType` and `processNamespace` methods:
+in `onTypeLoaded` and `onNamespaceLoaded` methods:
 
 ```typescript
 interface MyTypeConfig {
@@ -372,7 +532,7 @@ interface MyPluginConfig {
 const plugin: Plugin<MyTypeConfig, MyPluginConfig> = {
   id: "@example/my-plugin",
   // ...
-  processType(context) {
+  onTypeLoaded(context) {
     // context.typeConfig is MyTypeConfig
     // context.pluginConfig is MyPluginConfig
   },
@@ -407,56 +567,3 @@ declare module "@tailor-platform/sdk" {
   }
 }
 ```
-
-## Plugin Types
-
-### Type-Attached Plugins
-
-Implement `processType` to handle types with the plugin attached:
-
-```typescript
-const plugin: Plugin = {
-  id: "@example/my-plugin",
-  // ...
-  processType(context) {
-    // Called for each type with .plugin({ "@example/my-plugin": config })
-    return {
-      types: {
-        /* generated types */
-      },
-    };
-  },
-};
-```
-
-### Namespace Plugins
-
-Implement `processNamespace` for plugins that generate types independently:
-
-```typescript
-const plugin: Plugin = {
-  id: "@example/audit-log",
-  // ...
-  processNamespace(context) {
-    // Called once per namespace, with namespace-level types available
-    return { types: { auditLog: /* generated type */ } };
-  },
-};
-```
-
-### Hybrid Plugins
-
-Implement both methods for plugins that support both modes:
-
-```typescript
-const plugin: Plugin = {
-  id: "@example/hybrid",
-  // ...
-  processType(context) {
-    // Handle type attachments
-  },
-  processNamespace(context) {
-    // Handle namespace generation
-  },
-};
-```

package/docs/plugin/index.md

@@ -2,7 +2,7 @@
 
 > **Beta Feature**: The plugin system is currently in beta. APIs may change in future releases.
 
-Plugins extend TailorDB types by automatically generating additional types and executors based on your type definitions.
+Plugins extend TailorDB types by automatically generating additional types, executors, and output files based on your type definitions.
 
 ## Overview
 
@@ -100,6 +100,7 @@ Plugins can generate:
 - **Types**: Additional TailorDB types (e.g., `CustomerHistory`, `Deleted_Customer`)
 - **Executors**: Event handlers triggered by record changes
 - **Field Extensions**: Additional fields added to the source type
+- **Output Files**: TypeScript code and other files via generation-time hooks
 
 Generated files are placed under `.tailor-sdk/<plugin-id>/` (the plugin ID is sanitized,
 e.g. `@example/soft-delete` → `example-soft-delete`), such as:
@@ -107,6 +108,51 @@ e.g. `@example/soft-delete` → `example-soft-delete`), such as:
 - `.tailor-sdk/example-soft-delete/types`
 - `.tailor-sdk/example-soft-delete/executors`
 
+## Plugin Lifecycle
+
+Plugins have 5 hooks across two lifecycle phases. Each hook fires at a specific point in the `tailor-sdk generate` pipeline:
+
+```
+tailor-sdk generate
+│
+├─ Load TailorDB types
+│   ├─ onTypeLoaded        ← per type with .plugin() attached
+│   └─ onNamespaceLoaded   ← once per namespace (namespace plugins)
+│
+├─ Resolve Auth
+│
+├─ onTailorDBReady           ← all types finalized
+│
+├─ Load Resolvers
+│
+├─ onResolverReady           ← all resolvers finalized
+│
+├─ Load Executors
+│
+└─ onExecutorReady           ← all executors finalized
+```
+
+### Definition-time hooks
+
+| Hook                | Trigger                             | Can do                                                          |
+| ------------------- | ----------------------------------- | --------------------------------------------------------------- |
+| `onTypeLoaded`      | Each type with `.plugin()` attached | Generate types, resolvers, executors; extend source type fields |
+| `onNamespaceLoaded` | Once per namespace                  | Generate types, resolvers, executors                            |
+
+These hooks produce TailorDB types, resolvers, and executors that become part of the application. Requires `importPath` on the plugin.
+
+### Generation-time hooks
+
+| Hook              | Available data                             | Can do             |
+| ----------------- | ------------------------------------------ | ------------------ |
+| `onTailorDBReady` | TailorDB types, Auth                       | Write output files |
+| `onResolverReady` | TailorDB types, Resolvers, Auth            | Write output files |
+| `onExecutorReady` | TailorDB types, Resolvers, Executors, Auth | Write output files |
+
+These hooks receive all finalized data and produce output files (TypeScript code, etc.). They replace the previous standalone `defineGenerators()` approach. No `importPath` required.
+
+A plugin can implement hooks from either or both phases.
+
 ## Creating Custom Plugins
 
-See [Custom Plugins](./custom.md) for how to create your own plugins.
+See [Custom Plugins](./custom.md) for the full hook reference and examples.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tailor-platform/sdk",
-  "version": "1.17.1",
+  "version": "1.18.0",
   "description": "Tailor Platform SDK - The SDK to work with Tailor Platform",
   "license": "MIT",
   "repository": {
@@ -48,6 +48,26 @@
       "types": "./dist/plugin/index.d.mts",
       "import": "./dist/plugin/index.mjs",
       "default": "./dist/plugin/index.mjs"
+    },
+    "./plugin/kysely-type": {
+      "types": "./dist/plugin/builtin/kysely-type/index.d.mts",
+      "import": "./dist/plugin/builtin/kysely-type/index.mjs",
+      "default": "./dist/plugin/builtin/kysely-type/index.mjs"
+    },
+    "./plugin/enum-constants": {
+      "types": "./dist/plugin/builtin/enum-constants/index.d.mts",
+      "import": "./dist/plugin/builtin/enum-constants/index.mjs",
+      "default": "./dist/plugin/builtin/enum-constants/index.mjs"
+    },
+    "./plugin/file-utils": {
+      "types": "./dist/plugin/builtin/file-utils/index.d.mts",
+      "import": "./dist/plugin/builtin/file-utils/index.mjs",
+      "default": "./dist/plugin/builtin/file-utils/index.mjs"
+    },
+    "./plugin/seed": {
+      "types": "./dist/plugin/builtin/seed/index.d.mts",
+      "import": "./dist/plugin/builtin/seed/index.mjs",
+      "default": "./dist/plugin/builtin/seed/index.mjs"
     }
   },
   "dependencies": {
@@ -78,7 +98,7 @@
     "p-limit": "7.2.0",
     "pathe": "2.0.3",
     "pkg-types": "2.3.0",
-    "politty": "^0.3.0",
+    "politty": "^0.4.0",
     "rolldown": "1.0.0-beta.60",
     "serve": "14.2.5",
     "std-env": "3.10.0",