refactor(core): replace tegg-specific types with generic extensions

Remove ManifestTegg, ManifestModuleReference, ManifestModuleDescriptor
from core. Replace `tegg` field with `extensions: Record<string, unknown>`
so plugins can store arbitrary manifest data without core knowing the shape.

- ManifestStore.tegg getter → getExtension(name) method
- generateManifest(tegg?) → generateManifest(extensions?)
- Remove teggManifestCollector from EggLoader
- Add expected-manifest.json fixture showing full manifest structure

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: killagu

packages/core/src/loader/egg_loader.ts

@@ -23,7 +23,7 @@ import { sequencify } from '../utils/sequencify.ts';
 import { Timing } from '../utils/timing.ts';
 import { type ContextLoaderOptions, ContextLoader } from './context_loader.ts';
 import { type FileLoaderOptions, CaseStyle, FULLPATH, FileLoader } from './file_loader.ts';
-import { ManifestStore, type ManifestTegg, type StartupManifest } from './manifest.ts';
+import { ManifestStore, type StartupManifest } from './manifest.ts';
 
 const debug = debuglog('egg/core/loader/egg_loader');
 
@@ -76,8 +76,6 @@ export class EggLoader {
   readonly resolveCacheCollector: Record<string, string | null> = {};
   /** Collected file discovery results for manifest generation */
   readonly fileDiscoveryCollector: Record<string, string[]> = {};
-  /** Collected tegg manifest data (populated by tegg plugin) */
-  teggManifestCollector?: ManifestTegg;
 
   /**
    * @class
@@ -1781,13 +1779,13 @@ export class EggLoader {
    * Generate startup manifest from collected data.
    * Should be called after all loading phases complete.
    */
-  generateManifest(tegg?: ManifestTegg): StartupManifest {
+  generateManifest(extensions?: Record<string, unknown>): StartupManifest {
     return ManifestStore.generate({
       baseDir: this.options.baseDir,
       serverEnv: this.serverEnv,
       serverScope: this.serverScope,
       typescriptEnabled: isSupportTypeScript(),
-      tegg,
+      extensions,
       resolveCache: this.resolveCacheCollector,
       fileDiscovery: this.fileDiscoveryCollector,
     });

packages/core/src/loader/manifest.ts

@@ -10,25 +10,6 @@ const MANIFEST_VERSION = 1;
 
 const LOCKFILE_NAMES = ['pnpm-lock.yaml', 'package-lock.json', 'yarn.lock'] as const;
 
-export interface ManifestModuleReference {
-  name: string;
-  path: string;
-  optional?: boolean;
-}
-
-export interface ManifestModuleDescriptor {
-  name: string;
-  unitPath: string;
-  optional?: boolean;
-  /** Files containing decorated classes, relative to unitPath */
-  decoratedFiles: string[];
-}
-
-export interface ManifestTegg {
-  moduleReferences: ManifestModuleReference[];
-  moduleDescriptors: ManifestModuleDescriptor[];
-}
-
 export interface ManifestInvalidation {
   lockfileFingerprint: string;
   configFingerprint: string;
@@ -42,7 +23,8 @@ export interface StartupManifest {
   version: number;
   generatedAt: string;
   invalidation: ManifestInvalidation;
-  tegg: ManifestTegg;
+  /** Plugin-specific manifest data, keyed by plugin name */
+  extensions: Record<string, unknown>;
   /** resolveModule cache: filepath -> resolved path | null */
   resolveCache: Record<string, string | null>;
   /** directory path -> file relative paths (filtered) */
@@ -147,8 +129,8 @@ export class ManifestStore {
     return this.data.fileDiscovery?.[directory];
   }
 
-  get tegg(): ManifestTegg | undefined {
-    return this.data.tegg;
+  getExtension(name: string): unknown {
+    return this.data.extensions?.[name];
   }
 
   // --- Generation APIs ---
@@ -165,7 +147,7 @@ export class ManifestStore {
         baseDir: options.baseDir,
         typescriptEnabled: options.typescriptEnabled,
       },
-      tegg: options.tegg ?? { moduleReferences: [], moduleDescriptors: [] },
+      extensions: options.extensions ?? {},
       resolveCache: options.resolveCache ?? {},
       fileDiscovery: options.fileDiscovery ?? {},
     };
@@ -256,7 +238,7 @@ export interface ManifestGenerateOptions {
   serverEnv: string;
   serverScope: string;
   typescriptEnabled: boolean;
-  tegg?: ManifestTegg;
+  extensions?: Record<string, unknown>;
   resolveCache?: Record<string, string | null>;
   fileDiscovery?: Record<string, string[]>;
 }

packages/core/test/fixtures/manifest/expected-manifest.json

@@ -0,0 +1,44 @@
+{
+  "version": 1,
+  "generatedAt": "2026-03-28T04:00:00.000Z",
+  "invalidation": {
+    "lockfileFingerprint": "pnpm-lock.yaml:1711584000000:128",
+    "configFingerprint": "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4",
+    "serverEnv": "prod",
+    "serverScope": "",
+    "baseDir": "/app/my-egg-project",
+    "typescriptEnabled": true
+  },
+  "extensions": {
+    "tegg": {
+      "moduleReferences": [
+        { "name": "app", "path": "/app/my-egg-project/app" },
+        { "name": "my-plugin", "path": "/app/my-egg-project/node_modules/my-plugin", "optional": true }
+      ],
+      "moduleDescriptors": [
+        {
+          "name": "app",
+          "unitPath": "/app/my-egg-project/app",
+          "decoratedFiles": ["controller/home.ts", "service/user.ts"]
+        }
+      ]
+    }
+  },
+  "resolveCache": {
+    "/app/my-egg-project/config/plugin.default": "/app/my-egg-project/config/plugin.default.ts",
+    "/app/my-egg-project/config/plugin": null,
+    "/app/my-egg-project/config/config.default": "/app/my-egg-project/config/config.default.ts",
+    "/app/my-egg-project/config/config.prod": "/app/my-egg-project/config/config.prod.ts",
+    "/app/my-egg-project/app/router": "/app/my-egg-project/app/router.ts",
+    "/app/my-egg-project/node_modules/egg-security/config/config.default": "/app/my-egg-project/node_modules/egg-security/config/config.default.js",
+    "/app/my-egg-project/node_modules/egg-security/app": "/app/my-egg-project/node_modules/egg-security/app.js",
+    "/app/my-egg-project/node_modules/egg-session/config/config.default": null,
+    "/app/my-egg-project/app/app": null
+  },
+  "fileDiscovery": {
+    "/app/my-egg-project/app/controller": ["home.ts", "user.ts", "admin/dashboard.ts"],
+    "/app/my-egg-project/app/service": ["user.ts", "auth.ts"],
+    "/app/my-egg-project/app/middleware": ["auth.ts", "error_handler.ts"],
+    "/app/my-egg-project/node_modules/egg-security/app/middleware": ["csrf.js", "xframe.js"]
+  }
+}

packages/core/test/loader/manifest.test.ts

@@ -55,21 +55,18 @@ describe('ManifestStore', () => {
           typescriptEnabled: false,
         });
 
-        assert.deepStrictEqual(manifest.tegg, { moduleReferences: [], moduleDescriptors: [] });
+        assert.deepStrictEqual(manifest.extensions, {});
         assert.deepStrictEqual(manifest.resolveCache, {});
         assert.deepStrictEqual(manifest.fileDiscovery, {});
       } finally {
         fs.rmSync(baseDir, { recursive: true, force: true });
       }
     });
 
-    it('should preserve provided tegg, resolveCache, fileDiscovery', () => {
+    it('should preserve provided extensions, resolveCache, fileDiscovery', () => {
       const baseDir = setupBaseDir();
       try {
-        const tegg = {
-          moduleReferences: [{ name: 'mod', path: '/tmp/mod' }],
-          moduleDescriptors: [{ name: 'mod', unitPath: '/tmp/mod', decoratedFiles: ['a.ts'] }],
-        };
+        const extensions = { tegg: { moduleReferences: [{ name: 'mod', path: '/tmp/mod' }] } };
         const resolveCache = { '/foo/bar': '/resolved/bar', '/foo/missing': null };
         const fileDiscovery = { '/app/service': ['user.ts', 'post.ts'] };
 
@@ -78,12 +75,12 @@ describe('ManifestStore', () => {
           serverEnv: 'prod',
           serverScope: '',
           typescriptEnabled: true,
-          tegg,
+          extensions,
           resolveCache,
           fileDiscovery,
         });
 
-        assert.deepStrictEqual(manifest.tegg, tegg);
+        assert.deepStrictEqual(manifest.extensions, extensions);
         assert.deepStrictEqual(manifest.resolveCache, resolveCache);
         assert.deepStrictEqual(manifest.fileDiscovery, fileDiscovery);
       } finally {

packages/core/test/loader/manifest_query.test.ts

@@ -82,17 +82,25 @@ describe('ManifestStore query APIs', () => {
     });
   });
 
-  describe('tegg getter', () => {
-    it('should return tegg data', async () => {
+  describe('getExtension()', () => {
+    it('should return extension data by name', async () => {
       const baseDir = setupBaseDir();
-      const tegg = {
-        moduleReferences: [{ name: 'myModule', path: '/tmp/myModule' }],
-        moduleDescriptors: [],
-      };
+      const extensions = { tegg: { moduleReferences: [{ name: 'myModule', path: '/tmp/myModule' }] } };
       try {
-        await generateAndWrite(baseDir, { tegg });
+        await generateAndWrite(baseDir, { extensions });
         const store = ManifestStore.load(baseDir, 'prod', '')!;
-        assert.deepStrictEqual(store.tegg, tegg);
+        assert.deepStrictEqual(store.getExtension('tegg'), extensions.tegg);
+      } finally {
+        fs.rmSync(baseDir, { recursive: true, force: true });
+      }
+    });
+
+    it('should return undefined for unknown extension', async () => {
+      const baseDir = setupBaseDir();
+      try {
+        await generateAndWrite(baseDir, { extensions: {} });
+        const store = ManifestStore.load(baseDir, 'prod', '')!;
+        assert.equal(store.getExtension('nonexistent'), undefined);
       } finally {
         fs.rmSync(baseDir, { recursive: true, force: true });
       }

packages/core/test/loader/manifest_roundtrip.test.ts

@@ -23,10 +23,7 @@ describe('ManifestStore roundtrip: generate → write → load', () => {
     try {
       const resolveCache = { '/some/path': '/resolved/path', '/missing': null };
       const fileDiscovery = { '/app/controller': ['home.ts', 'user.ts'] };
-      const tegg = {
-        moduleReferences: [{ name: 'foo', path: '/tmp/foo', optional: true }],
-        moduleDescriptors: [{ name: 'foo', unitPath: '/tmp/foo', decoratedFiles: ['service.ts'] }],
-      };
+      const extensions = { tegg: { moduleReferences: [{ name: 'foo', path: '/tmp/foo' }] } };
 
       const original = ManifestStore.generate({
         baseDir,
@@ -35,15 +32,15 @@ describe('ManifestStore roundtrip: generate → write → load', () => {
         typescriptEnabled: true,
         resolveCache,
         fileDiscovery,
-        tegg,
+        extensions,
       });
       await ManifestStore.write(baseDir, original);
 
       const store = ManifestStore.load(baseDir, 'prod', '')!;
       assert.ok(store);
       assert.deepStrictEqual(store.data.resolveCache, resolveCache);
       assert.deepStrictEqual(store.data.fileDiscovery, fileDiscovery);
-      assert.deepStrictEqual(store.data.tegg, tegg);
+      assert.deepStrictEqual(store.data.extensions, extensions);
       assert.equal(store.data.version, original.version);
       assert.equal(store.data.generatedAt, original.generatedAt);
     } finally {
@@ -89,4 +86,37 @@ describe('ManifestStore roundtrip: generate → write → load', () => {
       fs.rmSync(baseDir, { recursive: true, force: true });
     }
   });
+
+  it('should match expected manifest fixture structure', async () => {
+    const fixturePath = path.join(__dirname, '../fixtures/manifest/expected-manifest.json');
+    const expected = JSON.parse(fs.readFileSync(fixturePath, 'utf-8'));
+
+    // Verify the fixture conforms to StartupManifest structure
+    assert.equal(expected.version, 1);
+    assert.ok(expected.generatedAt);
+    assert.ok(expected.invalidation);
+    assert.equal(expected.invalidation.serverEnv, 'prod');
+    assert.ok(typeof expected.invalidation.lockfileFingerprint === 'string');
+    assert.ok(typeof expected.invalidation.configFingerprint === 'string');
+    assert.ok(typeof expected.invalidation.typescriptEnabled === 'boolean');
+
+    // extensions is a generic Record<string, unknown>
+    assert.ok(typeof expected.extensions === 'object');
+    assert.ok(expected.extensions.tegg);
+    assert.ok(Array.isArray(expected.extensions.tegg.moduleReferences));
+
+    // resolveCache: string -> string | null
+    assert.ok(typeof expected.resolveCache === 'object');
+    for (const [key, value] of Object.entries(expected.resolveCache)) {
+      assert.ok(typeof key === 'string');
+      assert.ok(value === null || typeof value === 'string', `resolveCache[${key}] should be string | null`);
+    }
+
+    // fileDiscovery: string -> string[]
+    assert.ok(typeof expected.fileDiscovery === 'object');
+    for (const [key, value] of Object.entries(expected.fileDiscovery)) {
+      assert.ok(typeof key === 'string');
+      assert.ok(Array.isArray(value), `fileDiscovery[${key}] should be string[]`);
+    }
+  });
 });