@supacloud/compiler 0.5.0 → 0.6.0

package/dist/cli.js

@@ -1,17 +1,335 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { resolve as resolve3 } from "node:path";
+import { resolve as resolve5 } from "node:path";
 
 // src/analyze.ts
-import { existsSync } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import { relative, resolve as resolvePath, sep } from "node:path";
+import * as ts3 from "@typescript/typescript6";
+
+// src/program.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import * as ts2 from "@typescript/typescript6";
+
+// src/traits.ts
 import { createHash } from "node:crypto";
-import { join, relative, sep } from "node:path";
-import {
-  Node,
-  Project,
-  SyntaxKind
-} from "ts-morph";
+import * as ts from "@typescript/typescript6";
+class TraitCompiler {
+  handlers;
+  constructor(handlers = createDefaultTraitHandlers()) {
+    this.handlers = handlers;
+  }
+  compile(program, previous, changedFiles) {
+    const byFile = new Map;
+    for (const sourceFile of program.getSourceFiles()) {
+      if (sourceFile.isDeclarationFile || sourceFile.fileName.includes("/node_modules/"))
+        continue;
+      const previousTraits = previous?.byFile.get(sourceFile.fileName);
+      if (previousTraits && !changedFiles.has(sourceFile.fileName)) {
+        byFile.set(sourceFile.fileName, previousTraits);
+        continue;
+      }
+      byFile.set(sourceFile.fileName, this.compileSourceFile(sourceFile));
+    }
+    const all = [...byFile.values()].flat().sort((a, b) => a.file.localeCompare(b.file) || a.start - b.start || a.kind.localeCompare(b.kind));
+    return { byFile, all };
+  }
+  compileSourceFile(sourceFile) {
+    const traits = [];
+    const visit = (node) => {
+      for (const handler of this.handlers) {
+        const name = handler.detect(node);
+        if (name)
+          traits.push(record(handler.kind, name, sourceFile, node));
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return traits;
+  }
+}
+function compileTraits(program, previous, changedFiles) {
+  return new TraitCompiler().compile(program, previous, changedFiles);
+}
+function record(kind, name, sourceFile, node) {
+  const text = node.getText(sourceFile);
+  return {
+    kind,
+    name,
+    file: sourceFile.fileName,
+    start: node.getStart(sourceFile),
+    end: node.end,
+    fingerprint: createHash("sha1").update(`${kind}:${text}`).digest("hex")
+  };
+}
+function decoratorName(decorator) {
+  return expressionName(ts.isCallExpression(decorator.expression) ? decorator.expression.expression : decorator.expression);
+}
+function expressionName(expression) {
+  if (ts.isIdentifier(expression))
+    return expression.text;
+  if (ts.isPropertyAccessExpression(expression))
+    return expression.name.text;
+  return "";
+}
+function createDefaultTraitHandlers() {
+  return [
+    {
+      kind: "module",
+      detect: decoratedDeclaration("Module")
+    },
+    {
+      kind: "injectable",
+      detect: decoratedDeclaration("Injectable")
+    },
+    {
+      kind: "controller",
+      detect: decoratedDeclaration("Controller")
+    },
+    {
+      kind: "command",
+      detect: decoratedDeclaration("Command")
+    },
+    {
+      kind: "query",
+      detect: decoratedDeclaration("Query")
+    },
+    {
+      kind: "defineModule",
+      detect: (node) => {
+        if (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name))
+          return;
+        const initializer = node.initializer;
+        return initializer && ts.isCallExpression(initializer) && expressionName(initializer.expression) === "defineModule" ? node.name.text : undefined;
+      }
+    },
+    {
+      kind: "injectionToken",
+      detect: (node) => {
+        if (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name))
+          return;
+        const initializer = node.initializer;
+        return initializer && ts.isNewExpression(initializer) && expressionName(initializer.expression) === "InjectionToken" ? node.name.text : undefined;
+      }
+    }
+  ];
+}
+function decoratedDeclaration(decorator) {
+  return (node) => {
+    if (!ts.isClassDeclaration(node) || !node.name)
+      return;
+    return (ts.getDecorators(node) ?? []).some((item) => decoratorName(item) === decorator) ? node.name.text : undefined;
+  };
+}
+
+// src/program.ts
+function createIncrementalProgramSession(projectRoot) {
+  const rootDir = resolve(projectRoot);
+  let projectConfig = readProjectConfig(rootDir);
+  let projectConfigKey = configKey(projectConfig);
+  let builder;
+  let traits;
+  const sourceFileCache = new Map;
+  return {
+    getProgram() {
+      if (!builder) {
+        throw new Error("incremental TypeScript program has not been initialized");
+      }
+      return builder.getProgram();
+    },
+    getTypeChecker() {
+      return this.getProgram().getTypeChecker();
+    },
+    update(rootNames, changedPaths = rootNames) {
+      const oldProgram = builder?.getProgram();
+      const oldSourceFiles = new Map(oldProgram?.getSourceFiles().map((sourceFile) => [canonical(sourceFile.fileName), sourceFile]) ?? []);
+      const nextProjectConfig = readProjectConfig(rootDir);
+      const nextProjectConfigKey = configKey(nextProjectConfig);
+      const configChanged = nextProjectConfigKey !== projectConfigKey;
+      const previousBuilder = configChanged ? undefined : builder;
+      if (configChanged) {
+        sourceFileCache.clear();
+        traits = undefined;
+      }
+      projectConfig = nextProjectConfig;
+      projectConfigKey = nextProjectConfigKey;
+      const normalizedRoots = [...new Set(rootNames.map((file) => resolve(rootDir, file)))].sort();
+      const normalizedChanged = [...new Set(changedPaths.map((file) => resolve(rootDir, file)))];
+      const invalidatedPaths = new Set(normalizedChanged.map(canonical));
+      for (const sourceFile of oldSourceFiles.values()) {
+        if (sourceVersion(sourceFile.fileName) !== sourceFileVersion(sourceFile)) {
+          invalidatedPaths.add(canonical(sourceFile.fileName));
+        }
+      }
+      const invalidateAllResolutions = configChanged || [...invalidatedPaths].some((fileName) => {
+        const wasInProgram = oldSourceFiles.has(fileName);
+        return wasInProgram !== existsSync(fileName);
+      });
+      for (const fileName of normalizedChanged) {
+        if (!existsSync(fileName))
+          sourceFileCache.delete(canonical(fileName));
+      }
+      const host = createHost(projectConfig.options, rootDir, sourceFileCache, invalidatedPaths, invalidateAllResolutions);
+      builder = ts2.createEmitAndSemanticDiagnosticsBuilderProgram(normalizedRoots, projectConfig.options, host, previousBuilder, projectConfig.errors, projectConfig.projectReferences);
+      const program = builder.getProgram();
+      const changedFiles = [];
+      const reusedFiles = [];
+      const currentPaths = new Set(program.getSourceFiles().map((file) => canonical(file.fileName)));
+      for (const sourceFile of program.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile)
+          continue;
+        const previous = oldSourceFiles.get(canonical(sourceFile.fileName));
+        if (previous && previous === sourceFile) {
+          reusedFiles.push(sourceFile.fileName);
+        } else {
+          changedFiles.push(sourceFile.fileName);
+        }
+      }
+      for (const [path, sourceFile] of oldSourceFiles) {
+        if (!sourceFile.isDeclarationFile && !currentPaths.has(path)) {
+          changedFiles.push(sourceFile.fileName);
+        }
+      }
+      for (const path of sourceFileCache.keys()) {
+        if (!currentPaths.has(path))
+          sourceFileCache.delete(path);
+      }
+      traits = compileTraits(program, traits, new Set(changedFiles));
+      return { changedFiles, reusedFiles, program };
+    },
+    getTraits() {
+      return traits?.all ?? [];
+    },
+    getDiagnostics() {
+      if (!builder)
+        return projectConfig.errors;
+      const program = builder.getProgram();
+      return [
+        ...projectConfig.errors,
+        ...program.getSyntacticDiagnostics()
+      ];
+    },
+    emit() {
+      if (!builder) {
+        throw new Error("incremental TypeScript program has not been initialized");
+      }
+      return builder.emit();
+    },
+    reset() {
+      builder = undefined;
+      projectConfig = readProjectConfig(rootDir);
+      projectConfigKey = configKey(projectConfig);
+      traits = undefined;
+      sourceFileCache.clear();
+    }
+  };
+}
+function createHost(options, rootDir, sourceFileCache, invalidatedPaths, invalidateAllResolutions) {
+  const host = ts2.createIncrementalCompilerHost(options, {
+    ...ts2.sys,
+    getCurrentDirectory: () => rootDir
+  });
+  host.hasInvalidatedResolutions = (filePath) => invalidateAllResolutions || invalidatedPaths.has(canonical(filePath));
+  const originalGetSourceFile = host.getSourceFile.bind(host);
+  host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+    const key = canonical(fileName);
+    const text = host.readFile(fileName);
+    if (text === undefined) {
+      sourceFileCache.delete(key);
+      return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+    }
+    const version = hashText(text);
+    const parseKey = sourceFileParseKey(languageVersion);
+    const cached = sourceFileCache.get(key);
+    if (!shouldCreateNewSourceFile && cached?.version === version && cached.parseKey === parseKey) {
+      return cached.sourceFile;
+    }
+    const sourceFile = originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+    if (sourceFile) {
+      sourceFileCache.set(key, { sourceFile, version: hashText(sourceFile.text), parseKey });
+    } else {
+      sourceFileCache.delete(key);
+    }
+    return sourceFile;
+  };
+  return host;
+}
+function canonical(fileName) {
+  const normalized = resolve(fileName);
+  return ts2.sys.useCaseSensitiveFileNames ? normalized : normalized.toLowerCase();
+}
+function sourceFileParseKey(languageVersion) {
+  return typeof languageVersion === "number" ? `target:${languageVersion}` : JSON.stringify({
+    languageVersion: languageVersion.languageVersion,
+    impliedNodeFormat: languageVersion.impliedNodeFormat,
+    jsDocParsingMode: languageVersion.jsDocParsingMode
+  });
+}
+function configKey(config) {
+  return JSON.stringify({
+    options: config.options,
+    projectReferences: config.projectReferences,
+    configFingerprint: config.configFingerprint
+  });
+}
+function hashText(text) {
+  return createHash2("sha1").update(text).digest("hex");
+}
+function sourceVersion(fileName) {
+  try {
+    return hashText(readFileSync(fileName, "utf8"));
+  } catch {
+    return "missing";
+  }
+}
+function sourceFileVersion(sourceFile) {
+  const descriptor = Object.getOwnPropertyDescriptor(sourceFile, "version");
+  return typeof descriptor?.value === "string" ? descriptor.value : undefined;
+}
+function readProjectConfig(rootDir) {
+  const configPath = join(rootDir, "tsconfig.json");
+  if (!existsSync(configPath)) {
+    return {
+      options: {
+        target: ts2.ScriptTarget.ES2022,
+        module: ts2.ModuleKind.ESNext,
+        moduleResolution: ts2.ModuleResolutionKind.Bundler,
+        experimentalDecorators: true,
+        allowJs: false,
+        skipLibCheck: true
+      },
+      errors: [],
+      projectReferences: undefined,
+      configFingerprint: "defaults"
+    };
+  }
+  const configReads = new Map;
+  const readConfig = (fileName) => {
+    const text = ts2.sys.readFile(fileName);
+    configReads.set(canonical(fileName), text === undefined ? "missing" : hashText(text));
+    return text;
+  };
+  const config = ts2.readConfigFile(configPath, readConfig);
+  if (config.error) {
+    return {
+      options: {},
+      errors: [config.error],
+      configFingerprint: JSON.stringify([...configReads])
+    };
+  }
+  const parsed = ts2.parseJsonConfigFileContent(config.config, { ...ts2.sys, readFile: readConfig }, dirname(configPath));
+  return {
+    options: parsed.options,
+    errors: parsed.errors,
+    projectReferences: parsed.projectReferences,
+    configFingerprint: JSON.stringify([...configReads])
+  };
+}
+
+// src/analyze.ts
 var DEFAULT_INCLUDE = ["**/*.module.ts", "**/*.ts"];
 var ROUTE_DECORATORS = {
   Get: "GET",
@@ -23,63 +341,118 @@ var ROUTE_DECORATORS = {
   Options: "OPTIONS"
 };
 var SCOPES = ["application", "request", "job"];
-async function analyzeProject(rootDir, include, cache) {
-  let project;
-  if (cache?.project) {
-    project = cache.project;
-    for (const sf of project.getSourceFiles()) {
-      sf.refreshFromFileSystemSync();
-    }
-  } else {
-    project = createProject(rootDir);
-    const patterns = (include ?? DEFAULT_INCLUDE).map((glob) => join(rootDir, glob));
-    project.addSourceFilesAtPaths(patterns);
-    if (cache)
-      cache.project = project;
-  }
-  const sourceFiles = project.getSourceFiles().filter((sf) => !sf.getFilePath().includes("node_modules") && !sf.isDeclarationFile()).sort((a, b) => a.getFilePath().localeCompare(b.getFilePath()));
+function isScope(value) {
+  return SCOPES.some((scope) => scope === value);
+}
+function nodeText(node) {
+  return node.getText(node.getSourceFile());
+}
+function lineOf(node) {
+  const sourceFile = node.getSourceFile();
+  return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+}
+function variableName(decl) {
+  return ts3.isIdentifier(decl.name) ? decl.name.text : nodeText(decl.name);
+}
+function propertyName(name) {
+  if (ts3.isIdentifier(name) || ts3.isPrivateIdentifier(name))
+    return name.text;
+  if (ts3.isStringLiteral(name) || ts3.isNumericLiteral(name))
+    return name.text;
+  return nodeText(name);
+}
+function parameterName(param) {
+  return ts3.isIdentifier(param.name) ? param.name.text : nodeText(param.name);
+}
+function decoratorsOf(node) {
+  return ts3.canHaveDecorators(node) ? ts3.getDecorators(node) ?? [] : [];
+}
+function decoratorArguments(dec) {
+  return ts3.isCallExpression(dec.expression) ? dec.expression.arguments : [];
+}
+function hasMethod(cls, name) {
+  return cls.members.some((member) => (ts3.isMethodDeclaration(member) || ts3.isGetAccessorDeclaration(member) || ts3.isSetAccessorDeclaration(member)) && member.name !== undefined && propertyName(member.name) === name);
+}
+function hasDestroyHook(cls) {
+  return hasMethod(cls, "onDestroy") || hasMethod(cls, "ngOnDestroy");
+}
+function descendantsOfKind(root, predicate) {
+  const result = [];
+  const visit = (node) => {
+    if (predicate(node))
+      result.push(node);
+    ts3.forEachChild(node, visit);
+  };
+  visit(root);
+  return result;
+}
+async function analyzeProject(rootDir, include, cache, changedPaths) {
+  const session = cache?.programSession ?? createIncrementalProgramSession(rootDir);
+  if (cache)
+    cache.programSession = session;
+  const rootNames = ts3.sys.readDirectory(rootDir, [".ts", ".tsx"], ["node_modules", "dist"], include ?? DEFAULT_INCLUDE);
+  const update = session.update(rootNames, changedPaths);
+  const program = update.program;
+  const checker = program.getTypeChecker();
+  const sourceFiles = program.getSourceFiles().filter((sf) => !sf.isDeclarationFile && !sf.fileName.includes("/node_modules/") && !sf.fileName.includes("/dist/") && isProjectSourceFile(sf, rootDir)).sort((a, b) => a.fileName.localeCompare(b.fileName));
   const ctx = {
     rootDir,
+    program,
+    checker,
     tokensByName: new Map,
     classesByName: new Map,
     diagnostics: []
   };
+  const nativeTraitFiles = new Map;
+  for (const diagnostic of session.getDiagnostics()) {
+    ctx.diagnostics.push(toCompilerDiagnostic(diagnostic, rootDir));
+  }
+  for (const trait of session.getTraits()) {
+    const kinds = nativeTraitFiles.get(trait.file) ?? new Set;
+    kinds.add(trait.kind);
+    nativeTraitFiles.set(trait.file, kinds);
+  }
   for (const sf of sourceFiles) {
     indexFile(sf, ctx);
   }
   const candidates = [];
   for (const sf of sourceFiles) {
-    for (const cls of sf.getClasses()) {
-      const moduleDec = findDecorator(cls, "Module");
-      if (!moduleDec)
-        continue;
-      const options = decoratorObjectArg(moduleDec);
-      if (!options)
-        continue;
-      candidates.push({
-        node: cls,
-        options,
-        className: cls.getName() ?? "<anonymous>",
-        file: sf.getFilePath(),
-        line: cls.getStartLineNumber()
-      });
+    const traits = nativeTraitFiles.get(sf.fileName);
+    if (!cache || traits?.has("module")) {
+      for (const cls of sf.statements.filter(ts3.isClassDeclaration)) {
+        const moduleDec = findDecorator(cls, "Module");
+        if (!moduleDec)
+          continue;
+        const options = decoratorObjectArg(moduleDec);
+        if (!options)
+          continue;
+        candidates.push({
+          node: cls,
+          options,
+          className: cls.name?.text ?? "<anonymous>",
+          file: sf.fileName,
+          line: lineOf(cls)
+        });
+      }
     }
-    for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-      if (call.getExpression().getText() !== "defineModule")
-        continue;
-      const parent = call.getParent();
-      if (!parent || !Node.isVariableDeclaration(parent))
-        continue;
-      const arg = call.getArguments()[0];
-      if (!arg || !Node.isObjectLiteralExpression(arg))
-        continue;
-      candidates.push({
-        node: parent,
-        options: arg,
-        className: parent.getName(),
-        file: sf.getFilePath(),
-        line: parent.getStartLineNumber()
-      });
+    if (!cache || traits?.has("defineModule")) {
+      for (const call of descendantsOfKind(sf, ts3.isCallExpression)) {
+        if (nodeText(call.expression) !== "defineModule")
+          continue;
+        const parent = call.parent;
+        if (!parent || !ts3.isVariableDeclaration(parent))
+          continue;
+        const arg = call.arguments[0];
+        if (!arg || !ts3.isObjectLiteralExpression(arg))
+          continue;
+        candidates.push({
+          node: parent,
+          options: arg,
+          className: variableName(parent),
+          file: sf.fileName,
+          line: lineOf(parent)
+        });
+      }
     }
   }
   const nameByNode = new Map;
@@ -92,8 +465,8 @@ async function analyzeProject(rootDir, include, cache) {
   if (cache) {
     const currentFileHashes = new Map;
     for (const sf of sourceFiles) {
-      const rel = sourcePath(rootDir, sf.getFilePath());
-      const hash = createHash("sha256").update(sf.getFullText()).digest("hex");
+      const rel = sourcePath(rootDir, sf.fileName);
+      const hash = createHash3("sha256").update(sf.getFullText()).digest("hex");
       currentFileHashes.set(rel, hash);
     }
     const changedFiles = new Set;
@@ -109,7 +482,7 @@ async function analyzeProject(rootDir, include, cache) {
     }
     const modulesToKeep = new Map;
     const finalModules = [];
-    const finalDiagnostics = [];
+    const finalDiagnostics = [...ctx.diagnostics];
     const affectedModuleNames = cache.dependencyGraph && typeof cache.dependencyGraph.getAffectedModules === "function" ? new Set(cache.dependencyGraph.getAffectedModules(Array.from(changedFiles))) : new Set;
     for (const [modName, entry] of cache.modules.entries()) {
       const hasChangedFile = entry.ownedFiles.some((f) => changedFiles.has(f));
@@ -131,14 +504,7 @@ async function analyzeProject(rootDir, include, cache) {
       const diagBefore = ctx.diagnostics.length;
       const parsed = parseModule(c, nameByNode, ctx);
       const moduleDiagnostics = ctx.diagnostics.slice(diagBefore);
-      const ownedFiles = new Set;
-      ownedFiles.add(parsed.file);
-      for (const p of parsed.providers)
-        if (p.file)
-          ownedFiles.add(p.file);
-      for (const ctrl of parsed.controllers)
-        if (ctrl.file)
-          ownedFiles.add(ctrl.file);
+      const ownedFiles = collectModuleSourceClosure(parsed, ctx);
       const fileHashes = {};
       for (const f of ownedFiles) {
         fileHashes[f] = currentFileHashes.get(f) ?? "";
@@ -165,6 +531,7 @@ async function analyzeProject(rootDir, include, cache) {
   } else {
     modules = candidates.map((c) => parseModule(c, nameByNode, ctx));
   }
+  modules.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
   const allRegisteredClasses = new Set;
   const allRegisteredControllers = new Set;
   const allRegisteredCommands = new Set;
@@ -189,9 +556,9 @@ async function analyzeProject(rootDir, include, cache) {
     if (!allRegisteredClasses.has(name)) {
       const injectable = parseInjectableOptions(classInfo.decl, ctx);
       if (injectable?.providedIn === "root") {
-        const { deps, optionalDeps, selfDeps, skipSelfDeps, hostDeps, missing } = classDeps(classInfo.decl, ctx);
+        const { deps, optionalDeps, selfDeps, skipSelfDeps, hostDeps, functionalInjects, missing } = classDeps(classInfo.decl, ctx);
         const file = sourcePath(ctx.rootDir, classInfo.file);
-        const line = classInfo.decl.getStartLineNumber();
+        const line = lineOf(classInfo.decl);
         if (missing) {
           warn(ctx, "missing-deps", `root provider ${name} 的部分构造依赖无法静态解析`, file, line);
         }
@@ -206,8 +573,9 @@ async function analyzeProject(rootDir, include, cache) {
           selfDeps: selfDeps.length > 0 ? selfDeps : undefined,
           skipSelfDeps: skipSelfDeps.length > 0 ? skipSelfDeps : undefined,
           hostDeps: hostDeps.length > 0 ? hostDeps : undefined,
+          functionalInjects: functionalInjects.length > 0 ? functionalInjects : undefined,
           providedIn: "root",
-          hasOnDestroy: classInfo.decl.getMethod("onDestroy") !== undefined || undefined,
+          hasOnDestroy: hasDestroyHook(classInfo.decl) || undefined,
           exported: true,
           file,
           line,
@@ -218,8 +586,8 @@ async function analyzeProject(rootDir, include, cache) {
     if (!allRegisteredControllers.has(name)) {
       const controllerDec = findDecorator(classInfo.decl, "Controller");
       if (controllerDec) {
-        const arg = controllerDec.getArguments()[0];
-        const isStandalone = arg && Node.isObjectLiteralExpression(arg) && booleanProp(arg, "standalone");
+        const arg = decoratorArguments(controllerDec)[0];
+        const isStandalone = arg && ts3.isObjectLiteralExpression(arg) && booleanProp(arg, "standalone");
         if (isStandalone) {
           const ctrl = parseController(classInfo.decl, ctx);
           if (ctrl)
@@ -233,13 +601,14 @@ async function analyzeProject(rootDir, include, cache) {
         const meta = decoratorObjectArg(commandDec);
         if (meta && booleanProp(meta, "standalone")) {
           standaloneCommands.push({
-            className: classInfo.decl.getName() ?? name,
-            name: stringLiteralProp(meta, "name") ?? classInfo.decl.getName() ?? name,
+            className: classInfo.decl.name?.text ?? name,
+            name: stringLiteralProp(meta, "name") ?? classInfo.decl.name?.text ?? name,
             permission: stringLiteralProp(meta, "permission"),
             transaction: commandModeProp(meta, "transaction") ?? "none",
             audit: stringLiteralProp(meta, "audit"),
             idempotency: commandModeProp(meta, "idempotency") ?? "none",
-            standalone: true
+            standalone: true,
+            aspects: parseAspectRefs(getProp(meta, "aspects"), ctx, `command ${classInfo.decl.name?.text ?? name}`)
           });
         }
       }
@@ -264,13 +633,13 @@ async function analyzeProject(rootDir, include, cache) {
   if (rootProviders.length > 0 || standaloneControllers.length > 0 || standaloneCommands.length > 0) {
     const existingRoot = modules.find((m) => m.name === "root" || m.name === "app");
     if (existingRoot) {
-      existingRoot.providers.push(...rootProviders);
-      existingRoot.controllers.push(...standaloneControllers);
-      existingRoot.commands.push(...standaloneCommands);
-      for (const p of rootProviders) {
-        if (!existingRoot.exports.includes(p.token))
-          existingRoot.exports.push(p.token);
-      }
+      modules = modules.map((module) => module === existingRoot ? {
+        ...module,
+        providers: [...module.providers, ...rootProviders],
+        controllers: [...module.controllers, ...standaloneControllers],
+        commands: [...module.commands, ...standaloneCommands],
+        exports: [...new Set([...module.exports, ...rootProviders.map((provider) => provider.token)])]
+      } : module);
     } else {
       const fallbackFile = rootProviders[0]?.file ?? standaloneControllers[0]?.file ?? "root.ts";
       modules.unshift({
@@ -309,25 +678,72 @@ async function analyzeProject(rootDir, include, cache) {
     cacheStats: cache ? { reusedModules, reanalyzedModules } : undefined
   };
 }
-function createProject(rootDir) {
-  const tsConfigFilePath = join(rootDir, "tsconfig.json");
-  if (existsSync(tsConfigFilePath)) {
-    return new Project({ tsConfigFilePath, skipAddingFilesFromTsConfig: true });
+function collectModuleSourceClosure(module, ctx) {
+  const seeds = new Set;
+  const addRelativeModule = (path) => {
+    if (!path)
+      return;
+    const withExtension = /\.(tsx?|mts|cts|js)$/.test(path) ? path : `${path}.ts`;
+    seeds.add(resolveSourcePath(ctx.rootDir, withExtension));
+  };
+  addRelativeModule(module.file);
+  for (const provider of module.providers)
+    addRelativeModule(provider.importPath);
+  for (const controller of module.controllers)
+    addRelativeModule(controller.importPath);
+  const ownedFiles = new Set;
+  const queue = [...seeds];
+  while (queue.length > 0) {
+    const fileName = queue.shift();
+    if (!fileName)
+      continue;
+    const sourceFile = ctx.program.getSourceFile(fileName);
+    if (!sourceFile || sourceFile.isDeclarationFile || !isProjectSourceFile(sourceFile, ctx.rootDir))
+      continue;
+    const relativeFile = sourcePath(ctx.rootDir, sourceFile.fileName);
+    if (ownedFiles.has(relativeFile))
+      continue;
+    ownedFiles.add(relativeFile);
+    for (const statement of sourceFile.statements) {
+      let moduleName;
+      if (ts3.isImportDeclaration(statement) && ts3.isStringLiteral(statement.moduleSpecifier)) {
+        moduleName = statement.moduleSpecifier.text;
+      } else if (ts3.isExportDeclaration(statement) && statement.moduleSpecifier && ts3.isStringLiteral(statement.moduleSpecifier)) {
+        moduleName = statement.moduleSpecifier.text;
+      } else if (ts3.isImportEqualsDeclaration(statement) && ts3.isExternalModuleReference(statement.moduleReference) && ts3.isStringLiteral(statement.moduleReference.expression)) {
+        moduleName = statement.moduleReference.expression.text;
+      }
+      if (!moduleName || moduleName.startsWith("node:"))
+        continue;
+      const resolved = ts3.resolveModuleName(moduleName, sourceFile.fileName, ctx.program.getCompilerOptions(), ts3.sys).resolvedModule?.resolvedFileName;
+      if (resolved && isProjectSourcePath(resolved, ctx.rootDir))
+        queue.push(resolved);
+    }
   }
-  return new Project({
-    compilerOptions: { experimentalDecorators: true, allowJs: false }
-  });
+  return ownedFiles;
+}
+function resolveSourcePath(rootDir, file) {
+  const normalized = file.replace(/\\/g, "/");
+  return resolvePath(rootDir, normalized);
+}
+function isProjectSourcePath(fileName, rootDir) {
+  const normalized = fileName.replace(/\\/g, "/");
+  const root = rootDir.replace(/\\/g, "/").replace(/\/+$/, "");
+  return normalized === root || normalized.startsWith(`${root}/`);
+}
+function isProjectSourceFile(sourceFile, rootDir) {
+  return isProjectSourcePath(sourceFile.fileName, rootDir) && /\.(tsx?|mts|cts)$/.test(sourceFile.fileName);
 }
 function indexFile(sf, ctx) {
-  for (const cls of sf.getClasses()) {
-    const name = cls.getName();
+  for (const cls of sf.statements.filter(ts3.isClassDeclaration)) {
+    const name = cls.name?.text;
     if (name && !ctx.classesByName.has(name)) {
-      ctx.classesByName.set(name, { name, decl: cls, file: sf.getFilePath() });
+      ctx.classesByName.set(name, { name, decl: cls, file: sf.fileName });
     }
   }
-  for (const statement of sf.getVariableStatements()) {
-    for (const decl of statement.getDeclarations()) {
-      const info = parseTokenVariable(decl, sf.getFilePath());
+  for (const statement of sf.statements.filter(ts3.isVariableStatement)) {
+    for (const decl of statement.declarationList.declarations) {
+      const info = parseTokenVariable(decl, sf.fileName);
       if (info && !ctx.tokensByName.has(info.name)) {
         ctx.tokensByName.set(info.name, info);
       }
@@ -335,19 +751,19 @@ function indexFile(sf, ctx) {
   }
 }
 function parseTokenVariable(decl, file) {
-  const init = decl.getInitializer();
-  if (!init || !Node.isNewExpression(init))
+  const init = decl.initializer;
+  if (!init || !ts3.isNewExpression(init))
     return;
-  if (init.getExpression().getText() !== "InjectionToken")
+  if (nodeText(init.expression) !== "InjectionToken")
     return;
-  const [nameArg, optionsArg] = init.getArguments();
-  const info = { name: decl.getName(), file, line: decl.getStartLineNumber() };
-  if (nameArg && Node.isStringLiteral(nameArg)) {
-    info.stringName = nameArg.getLiteralText();
+  const [nameArg, optionsArg] = init.arguments ?? [];
+  const info = { name: variableName(decl), file, line: lineOf(decl) };
+  if (nameArg && ts3.isStringLiteral(nameArg)) {
+    info.stringName = nameArg.text;
   }
-  if (optionsArg && Node.isObjectLiteralExpression(optionsArg)) {
+  if (optionsArg && ts3.isObjectLiteralExpression(optionsArg)) {
     const scope = stringLiteralProp(optionsArg, "scope");
-    if (scope && SCOPES.includes(scope)) {
+    if (scope && isScope(scope)) {
       info.scope = scope;
     }
     const providedIn = stringLiteralProp(optionsArg, "providedIn");
@@ -364,33 +780,76 @@ function parseTokenVariable(decl, file) {
 function parseModule(candidate, nameByNode, ctx) {
   const { options, className, file, line } = candidate;
   const name = nameByNode.get(candidate.node) ?? className;
-  const tags = arrayProp(options, "tags").map((el) => Node.isStringLiteral(el) ? el.getLiteralText() : el.getText().replace(/['"]/g, "")).filter(Boolean);
+  const tags = arrayProp(options, "tags").map((el) => ts3.isStringLiteral(el) ? el.text : nodeText(el).replace(/['"]/g, "")).filter(Boolean);
+  const aspects = parseAspectRefs(getProp(options, "aspects"), ctx, `module ${name}`);
   const imports = arrayProp(options, "imports").map((el) => {
     const unwrapped = unwrapForwardRef(el);
-    const decl = Node.isIdentifier(unwrapped) ? resolveDeclaration(unwrapped)[0] : undefined;
+    const decl = ts3.isIdentifier(unwrapped) ? resolveDeclaration(unwrapped, ctx)[0] : undefined;
     if (decl) {
       const known = nameByNode.get(decl);
       if (known)
         return known;
-      if (Node.isClassDeclaration(decl)) {
+      if (ts3.isClassDeclaration(decl)) {
         const dec = findDecorator(decl, "Module");
         const decOptions = dec && decoratorObjectArg(dec);
         const decName = decOptions && stringLiteralProp(decOptions, "name");
-        return decName ?? decl.getName() ?? el.getText();
+        return decName ?? decl.name?.text ?? nodeText(el);
       }
-      if (Node.isVariableDeclaration(decl))
-        return decl.getName();
+      if (ts3.isVariableDeclaration(decl))
+        return variableName(decl);
     }
-    return el.getText();
+    return nodeText(el);
   }).filter((v, i, arr) => arr.indexOf(v) === i);
   const exports = arrayProp(options, "exports").map((el) => tokenNameOf(el, ctx).name);
   const exportsSet = new Set(exports);
   const providers = [];
-  for (const el of arrayProp(options, "providers")) {
+  for (const el of expandProviderExpressions(arrayProp(options, "providers"), ctx)) {
+    const parsedProviders = parseFunctionalProvider(el, exportsSet, ctx);
+    if (parsedProviders) {
+      providers.push(...parsedProviders);
+      continue;
+    }
+    if (ts3.isCallExpression(el)) {
+      const helper = nodeText(el.expression).split(".").pop() ?? nodeText(el.expression);
+      warn(ctx, "unsupported-provider-helper", `无法静态展开 provider helper '${helper}'；请改用显式 Provider 或实现编译器支持的 helper`, sourcePath(ctx.rootDir, el.getSourceFile().fileName), lineOf(el));
+      continue;
+    }
     const provider = parseProvider(el, exportsSet, ctx);
     if (provider)
       providers.push(provider);
   }
+  for (const el of arrayProp(options, "jobs")) {
+    if (!ts3.isIdentifier(el))
+      continue;
+    const decl = resolveDeclaration(el, ctx)[0];
+    if (!decl || !ts3.isClassDeclaration(decl))
+      continue;
+    const className2 = decl.name?.text ?? el.text;
+    const registeredProvider = providers.find((provider) => provider.token === className2);
+    if (registeredProvider)
+      continue;
+    const deps = classDeps(decl, ctx);
+    const injectable = parseInjectableOptions(decl, ctx);
+    const scope = injectable?.scope === "application" ? "application" : "job";
+    providers.push({
+      token: className2,
+      tokenKind: "class",
+      kind: "class",
+      useClass: className2,
+      scope,
+      deps: deps.deps,
+      optionalDeps: deps.optionalDeps.length > 0 ? deps.optionalDeps : undefined,
+      selfDeps: deps.selfDeps.length > 0 ? deps.selfDeps : undefined,
+      skipSelfDeps: deps.skipSelfDeps.length > 0 ? deps.skipSelfDeps : undefined,
+      hostDeps: deps.hostDeps.length > 0 ? deps.hostDeps : undefined,
+      functionalInjects: deps.functionalInjects.length > 0 ? deps.functionalInjects : undefined,
+      hasOnDestroy: hasDestroyHook(decl) || undefined,
+      exported: exportsSet.has(className2),
+      file: sourcePath(ctx.rootDir, decl.getSourceFile().fileName),
+      line: lineOf(decl),
+      importPath: modulePath(ctx.rootDir, decl.getSourceFile().fileName)
+    });
+  }
   const controllers = [];
   for (const el of arrayProp(options, "controllers")) {
     const controller = parseController(el, ctx);
@@ -400,40 +859,59 @@ function parseModule(candidate, nameByNode, ctx) {
   const handlerClasses = [];
   const seenHandlers = new Set;
   const collectHandler = (expr) => {
-    if (!Node.isIdentifier(expr))
+    if (!ts3.isIdentifier(expr))
       return;
-    const decl = resolveDeclaration(expr)[0];
-    if (decl && Node.isClassDeclaration(decl) && !seenHandlers.has(decl.getName() ?? "")) {
-      seenHandlers.add(decl.getName() ?? "");
+    const decl = resolveDeclaration(expr, ctx)[0];
+    if (decl && ts3.isClassDeclaration(decl) && !seenHandlers.has(decl.name?.text ?? "")) {
+      seenHandlers.add(decl.name?.text ?? "");
       handlerClasses.push(decl);
     }
   };
   for (const el of arrayProp(options, "providers")) {
-    if (Node.isIdentifier(el))
+    if (ts3.isIdentifier(el))
       collectHandler(el);
-    if (Node.isObjectLiteralExpression(el)) {
+    if (ts3.isObjectLiteralExpression(el)) {
       const useClass = getProp(el, "useClass");
       if (useClass)
         collectHandler(useClass);
     }
   }
   arrayProp(options, "commands").forEach(collectHandler);
+  arrayProp(options, "jobs").forEach(collectHandler);
   arrayProp(options, "queries").forEach(collectHandler);
   const commands = [];
+  const jobs = [];
   const queries = [];
   for (const cls of handlerClasses) {
     const commandDec = findDecorator(cls, "Command");
     if (commandDec) {
       const meta = decoratorObjectArg(commandDec);
       if (meta) {
+        const aspects2 = parseAspectRefs(getProp(meta, "aspects"), ctx, `command ${cls.name?.text ?? "<anonymous>"}`);
         commands.push({
-          className: cls.getName() ?? "<anonymous>",
-          name: stringLiteralProp(meta, "name") ?? cls.getName() ?? "<anonymous>",
+          className: cls.name?.text ?? "<anonymous>",
+          name: stringLiteralProp(meta, "name") ?? cls.name?.text ?? "<anonymous>",
           permission: stringLiteralProp(meta, "permission"),
           transaction: commandModeProp(meta, "transaction") ?? "none",
           audit: stringLiteralProp(meta, "audit"),
           idempotency: commandModeProp(meta, "idempotency") ?? "none",
-          standalone: booleanProp(meta, "standalone") || undefined
+          ...booleanProp(meta, "standalone") ? { standalone: true } : {},
+          ...aspects2.length > 0 ? { aspects: aspects2 } : {}
+        });
+      }
+    }
+    const jobDec = findDecorator(cls, "Job");
+    if (jobDec) {
+      const meta = decoratorObjectArg(jobDec);
+      if (meta) {
+        const injectable = parseInjectableOptions(cls, ctx);
+        const provider = providers.find((candidate2) => candidate2.token === (cls.name?.text ?? "<anonymous>"));
+        const aspects2 = parseAspectRefs(getProp(meta, "aspects"), ctx, `job ${cls.name?.text ?? "<anonymous>"}`);
+        jobs.push({
+          className: cls.name?.text ?? "<anonymous>",
+          name: stringLiteralProp(meta, "name") ?? cls.name?.text ?? "<anonymous>",
+          scope: provider?.scope ?? (injectable?.scope === "application" ? "application" : "job"),
+          ...aspects2.length > 0 ? { aspects: aspects2 } : {}
         });
       }
     }
@@ -442,8 +920,8 @@ function parseModule(candidate, nameByNode, ctx) {
       const meta = decoratorObjectArg(queryDec);
       if (meta) {
         queries.push({
-          className: cls.getName() ?? "<anonymous>",
-          name: stringLiteralProp(meta, "name") ?? cls.getName() ?? "<anonymous>"
+          className: cls.name?.text ?? "<anonymous>",
+          name: stringLiteralProp(meta, "name") ?? cls.name?.text ?? "<anonymous>"
         });
       }
     }
@@ -458,7 +936,9 @@ function parseModule(candidate, nameByNode, ctx) {
     providers,
     controllers,
     commands,
+    jobs,
     queries,
+    ...aspects.length > 0 ? { aspects } : {},
     exports
   };
 }
@@ -467,14 +947,14 @@ function commandModeProp(object, name) {
   return value === "required" || value === "none" ? value : undefined;
 }
 function parseProvider(el, exportsSet, ctx) {
-  const file = sourcePath(ctx.rootDir, el.getSourceFile().getFilePath());
-  const line = el.getStartLineNumber();
+  const file = sourcePath(ctx.rootDir, el.getSourceFile().fileName);
+  const line = lineOf(el);
   const unwrappedEl = unwrapForwardRef(el);
-  if (Node.isIdentifier(unwrappedEl)) {
-    const decl = resolveDeclaration(unwrappedEl)[0];
-    const cls = decl && Node.isClassDeclaration(decl) ? decl : undefined;
-    const className = cls?.getName() ?? unwrappedEl.getText();
-    const { deps, optionalDeps, selfDeps, skipSelfDeps, hostDeps, missing } = cls ? classDeps(cls, ctx) : { deps: [], optionalDeps: [], selfDeps: [], skipSelfDeps: [], hostDeps: [], missing: false };
+  if (ts3.isIdentifier(unwrappedEl)) {
+    const decl = resolveDeclaration(unwrappedEl, ctx)[0];
+    const cls = decl && ts3.isClassDeclaration(decl) ? decl : undefined;
+    const className = cls?.name?.text ?? unwrappedEl.text;
+    const { deps, optionalDeps, selfDeps, skipSelfDeps, hostDeps, functionalInjects, missing } = cls ? classDeps(cls, ctx) : { deps: [], optionalDeps: [], selfDeps: [], skipSelfDeps: [], hostDeps: [], functionalInjects: [], missing: false };
     const injectable = cls ? parseInjectableOptions(cls, ctx) : undefined;
     if (missing) {
       warn(ctx, "missing-deps", `provider ${className} 的部分构造依赖无法静态解析`, file, line);
@@ -490,15 +970,16 @@ function parseProvider(el, exportsSet, ctx) {
       selfDeps: selfDeps.length > 0 ? selfDeps : undefined,
       skipSelfDeps: skipSelfDeps.length > 0 ? skipSelfDeps : undefined,
       hostDeps: hostDeps.length > 0 ? hostDeps : undefined,
+      functionalInjects: functionalInjects.length > 0 ? functionalInjects : undefined,
       providedIn: injectable?.providedIn,
-      hasOnDestroy: cls?.getMethod("onDestroy") !== undefined || undefined,
+      hasOnDestroy: cls ? hasDestroyHook(cls) || undefined : undefined,
       exported: exportsSet.has(className),
       file,
       line,
-      importPath: cls ? modulePath(ctx.rootDir, cls.getSourceFile().getFilePath()) : undefined
+      importPath: cls ? modulePath(ctx.rootDir, cls.getSourceFile().fileName) : undefined
     };
   }
-  if (!Node.isObjectLiteralExpression(el))
+  if (!ts3.isObjectLiteralExpression(el))
     return;
   const provideExpr = getProp(el, "provide");
   if (!provideExpr)
@@ -513,26 +994,36 @@ function parseProvider(el, exportsSet, ctx) {
   const useExistingExpr = getProp(el, "useExisting");
   if (useClassExpr) {
     const unwrappedClass = unwrapForwardRef(useClassExpr);
-    const decl = Node.isIdentifier(unwrappedClass) ? resolveDeclaration(unwrappedClass)[0] : undefined;
-    const cls = decl && Node.isClassDeclaration(decl) ? decl : undefined;
-    const useClass = cls?.getName() ?? unwrappedClass.getText();
+    const decl = ts3.isIdentifier(unwrappedClass) ? resolveDeclaration(unwrappedClass, ctx)[0] : undefined;
+    const cls = decl && ts3.isClassDeclaration(decl) ? decl : undefined;
+    const useClass = cls?.name?.text ?? nodeText(unwrappedClass);
     let deps = explicitDeps;
     let optionalDeps = [];
     let selfDeps = [];
     let skipSelfDeps = [];
     let hostDeps = [];
-    if (deps.length === 0 && cls) {
+    let functionalInjects = [];
+    if (cls) {
       const result = classDeps(cls, ctx);
-      deps = result.deps;
-      optionalDeps = result.optionalDeps;
-      selfDeps = result.selfDeps;
-      skipSelfDeps = result.skipSelfDeps;
-      hostDeps = result.hostDeps;
+      if (deps.length === 0) {
+        deps = result.deps;
+        optionalDeps = result.optionalDeps;
+        selfDeps = result.selfDeps;
+        skipSelfDeps = result.skipSelfDeps;
+        hostDeps = result.hostDeps;
+      } else {
+        optionalDeps = result.optionalDeps.filter((dep) => deps.includes(dep));
+        selfDeps = result.selfDeps.filter((dep) => deps.includes(dep));
+        skipSelfDeps = result.skipSelfDeps.filter((dep) => deps.includes(dep));
+        hostDeps = result.hostDeps.filter((dep) => deps.includes(dep));
+      }
+      functionalInjects = result.functionalInjects;
       if (result.missing) {
         warn(ctx, "missing-deps", `provider ${token} (useClass ${useClass}) 的部分构造依赖无法静态解析`, file, line);
       }
     }
     const injectable = cls ? parseInjectableOptions(cls, ctx) : undefined;
+    validateProviderCompatibility(provideExpr, useClassExpr, "class", token, ctx, file, line);
     return {
       token,
       tokenKind,
@@ -544,35 +1035,38 @@ function parseProvider(el, exportsSet, ctx) {
       selfDeps: selfDeps.length > 0 ? selfDeps : undefined,
       skipSelfDeps: skipSelfDeps.length > 0 ? skipSelfDeps : undefined,
       hostDeps: hostDeps.length > 0 ? hostDeps : undefined,
+      functionalInjects: functionalInjects.length > 0 ? functionalInjects : undefined,
       multi: multi ?? undefined,
       providedIn: injectable?.providedIn,
-      hasOnDestroy: cls?.getMethod("onDestroy") !== undefined || undefined,
+      hasOnDestroy: cls ? hasMethod(cls, "onDestroy") || undefined : undefined,
       exported: exportsSet.has(token),
       file,
       line,
-      importPath: cls ? modulePath(ctx.rootDir, cls.getSourceFile().getFilePath()) : undefined
+      importPath: cls ? modulePath(ctx.rootDir, cls.getSourceFile().fileName) : undefined
     };
   }
   if (useValueExpr) {
+    validateProviderCompatibility(provideExpr, useValueExpr, "value", token, ctx, file, line);
     return {
       token,
       tokenKind,
       kind: "value",
-      useValueExpr: useValueExpr.getText(),
+      useValueExpr: nodeText(useValueExpr),
       scope: resolveScope({ explicit: explicitScope, tokenName: token }, ctx),
       deps: [],
       multi: multi ?? undefined,
       exported: exportsSet.has(token),
       file,
       line,
-      importPath: Node.isIdentifier(useValueExpr) ? importPathOf(useValueExpr, ctx) : undefined
+      importPath: ts3.isIdentifier(useValueExpr) ? importPathOf(useValueExpr, ctx) : undefined
     };
   }
   if (useFactoryExpr) {
-    const factoryName = Node.isIdentifier(useFactoryExpr) ? (() => {
-      const decl = resolveDeclaration(useFactoryExpr)[0];
-      return decl && (Node.isFunctionDeclaration(decl) || Node.isVariableDeclaration(decl)) ? decl.getName() ?? useFactoryExpr.getText() : useFactoryExpr.getText();
-    })() : useFactoryExpr.getText();
+    const factoryName = ts3.isIdentifier(useFactoryExpr) ? (() => {
+      const decl = resolveDeclaration(useFactoryExpr, ctx)[0];
+      return decl && (ts3.isFunctionDeclaration(decl) || ts3.isVariableDeclaration(decl)) ? (ts3.isFunctionDeclaration(decl) ? decl.name?.text : variableName(decl)) ?? useFactoryExpr.text : useFactoryExpr.text;
+    })() : nodeText(useFactoryExpr);
+    validateProviderCompatibility(provideExpr, useFactoryExpr, "factory", token, ctx, file, line);
     return {
       token,
       tokenKind,
@@ -584,11 +1078,12 @@ function parseProvider(el, exportsSet, ctx) {
       exported: exportsSet.has(token),
       file,
       line,
-      importPath: Node.isIdentifier(useFactoryExpr) ? importPathOf(useFactoryExpr, ctx) : undefined
+      importPath: ts3.isIdentifier(useFactoryExpr) ? importPathOf(useFactoryExpr, ctx) : undefined
     };
   }
   if (useExistingExpr) {
     const target = tokenNameOf(useExistingExpr, ctx).name;
+    validateProviderCompatibility(provideExpr, useExistingExpr, "existing", token, ctx, file, line);
     return {
       token,
       tokenKind,
@@ -604,14 +1099,262 @@ function parseProvider(el, exportsSet, ctx) {
   }
   return;
 }
+function expandProviderExpressions(expressions, ctx, seen = new Set) {
+  const result = [];
+  for (const expression of expressions) {
+    if (ts3.isSpreadElement(expression)) {
+      result.push(...expandProviderExpressions([expression.expression], ctx, seen));
+      continue;
+    }
+    if (ts3.isIdentifier(expression)) {
+      const declaration = resolveDeclaration(expression, ctx)[0];
+      if (declaration && ts3.isVariableDeclaration(declaration) && declaration.initializer) {
+        const key = `${declaration.getSourceFile().fileName}:${declaration.pos}`;
+        if (seen.has(key))
+          continue;
+        const initializer = declaration.initializer;
+        if (ts3.isCallExpression(initializer) && isProviderHelper(initializer, "makeEnvironmentProviders")) {
+          const nested = initializer.arguments[0];
+          if (nested && ts3.isArrayLiteralExpression(nested)) {
+            seen.add(key);
+            result.push(...expandProviderExpressions([...nested.elements], ctx, seen));
+            seen.delete(key);
+            continue;
+          }
+        }
+      }
+    }
+    if (ts3.isCallExpression(expression) && isProviderHelper(expression, "makeEnvironmentProviders")) {
+      const nested = expression.arguments[0];
+      if (nested && ts3.isArrayLiteralExpression(nested)) {
+        result.push(...expandProviderExpressions([...nested.elements], ctx, seen));
+        continue;
+      }
+    }
+    result.push(expression);
+  }
+  return result;
+}
+function isProviderHelper(expression, name) {
+  return nodeText(expression.expression).split(".").pop() === name;
+}
+function parseFunctionalProvider(expression, exportsSet, ctx) {
+  if (!ts3.isCallExpression(expression))
+    return;
+  const helper = nodeText(expression.expression).split(".").pop();
+  const args = expression.arguments;
+  const file = sourcePath(ctx.rootDir, expression.getSourceFile().fileName);
+  const line = lineOf(expression);
+  if (helper === "provideToken") {
+    const tokenExpr = args[0];
+    const valueExpr = args[1];
+    if (!tokenExpr || !valueExpr)
+      return [];
+    const { name: token, kind: tokenKind } = tokenNameOf(tokenExpr, ctx);
+    validateProviderCompatibility(tokenExpr, valueExpr, "value", token, ctx, file, line);
+    return [{
+      token,
+      tokenKind,
+      kind: "value",
+      useValueExpr: nodeText(valueExpr),
+      scope: resolveScope({ tokenName: token }, ctx),
+      deps: [],
+      exported: exportsSet.has(token),
+      file,
+      line,
+      importPath: ts3.isIdentifier(valueExpr) ? importPathOf(valueExpr, ctx) : undefined
+    }];
+  }
+  if (helper === "provideAppInitializer" || helper === "provideEnvironmentInitializer") {
+    const initializer = args[0];
+    if (!initializer)
+      return [];
+    const token = helper === "provideAppInitializer" ? "APP_INITIALIZER" : "ENVIRONMENT_INITIALIZER";
+    return [{
+      token,
+      tokenKind: "injection-token",
+      kind: "value",
+      useValueExpr: nodeText(initializer),
+      scope: "application",
+      deps: [],
+      multi: true,
+      exported: false,
+      file,
+      line,
+      importPath: ts3.isIdentifier(initializer) ? importPathOf(initializer, ctx) : undefined
+    }];
+  }
+  if (helper === "provideRouter") {
+    const providers = [];
+    const routes = args[0];
+    if (routes) {
+      providers.push({
+        token: "ROUTE_CONFIG",
+        tokenKind: "injection-token",
+        kind: "value",
+        useValueExpr: nodeText(routes),
+        scope: "application",
+        deps: [],
+        exported: false,
+        file,
+        line,
+        importPath: ts3.isIdentifier(routes) ? importPathOf(routes, ctx) : undefined
+      });
+    }
+    for (const feature of args.slice(1)) {
+      if (!ts3.isCallExpression(feature))
+        continue;
+      const featureName = nodeText(feature.expression).split(".").pop();
+      if (featureName === "withRouterConfig" && feature.arguments[0]) {
+        providers.push({
+          token: "ROUTER_CONFIGURATION",
+          tokenKind: "injection-token",
+          kind: "value",
+          useValueExpr: nodeText(feature.arguments[0]),
+          scope: "application",
+          deps: [],
+          exported: false,
+          file,
+          line
+        });
+      } else if (featureName === "withTitleStrategy" && feature.arguments[0]) {
+        const strategy = feature.arguments[0];
+        const isClass = ts3.isIdentifier(strategy) && Boolean(resolveDeclaration(strategy, ctx).find((declaration) => ts3.isClassDeclaration(declaration)));
+        providers.push({
+          token: "TITLE_STRATEGY",
+          tokenKind: "injection-token",
+          kind: isClass ? "class" : "value",
+          ...isClass ? { useClass: nodeText(strategy) } : { useValueExpr: nodeText(strategy) },
+          scope: "application",
+          deps: [],
+          exported: false,
+          file,
+          line,
+          importPath: ts3.isIdentifier(strategy) ? importPathOf(strategy, ctx) : undefined
+        });
+      }
+    }
+    return providers;
+  }
+  if (helper === "provideHttpClient") {
+    const providers = [{
+      token: "HttpClient",
+      tokenKind: "class",
+      kind: "class",
+      useClass: "HttpClient",
+      scope: "application",
+      deps: ["HTTP_CLIENT_CONFIG", "HTTP_INTERCEPTORS"],
+      optionalDeps: ["HTTP_CLIENT_CONFIG", "HTTP_INTERCEPTORS"],
+      exported: false,
+      file,
+      line,
+      importModule: "@supacloud/app"
+    }];
+    for (const feature of args) {
+      if (!ts3.isCallExpression(feature))
+        continue;
+      const featureName = nodeText(feature.expression).split(".").pop();
+      if (featureName === "withInterceptors") {
+        for (const interceptorArg of feature.arguments) {
+          const values = ts3.isArrayLiteralExpression(interceptorArg) ? [...interceptorArg.elements] : [interceptorArg];
+          for (const value of values) {
+            providers.push({
+              token: "HTTP_INTERCEPTORS",
+              tokenKind: "injection-token",
+              kind: "value",
+              useValueExpr: nodeText(value),
+              scope: "application",
+              deps: [],
+              multi: true,
+              exported: false,
+              file,
+              line,
+              importPath: ts3.isIdentifier(value) ? importPathOf(value, ctx) : undefined
+            });
+          }
+        }
+      } else if (featureName === "withFetch" && feature.arguments.length > 0) {
+        warn(ctx, "unsupported-provider-helper", "provideHttpClient(withFetch(customFetch)) 需要显式声明 HTTP_CLIENT_CONFIG provider 才能保持静态生成", file, line);
+      }
+    }
+    return providers;
+  }
+  return;
+}
+function validateProviderCompatibility(provideExpr, implementationExpr, kind, tokenName, ctx, file, line) {
+  const expected = providerTokenValueType(provideExpr, ctx);
+  const actual = providerImplementationType(implementationExpr, kind, ctx);
+  if (!expected || !actual || isUnknownOrAny(expected) || isUnknownOrAny(actual))
+    return;
+  if (ctx.checker.isTypeAssignableTo(actual, expected))
+    return;
+  const providerKind = kind === "class" ? "useClass" : `use${kind.charAt(0).toUpperCase()}${kind.slice(1)}`;
+  ctx.diagnostics.push({
+    severity: "error",
+    code: "provider-type-mismatch",
+    message: `Provider '${tokenName}' 的 ${providerKind} 类型不满足 Token 契约：需要 ${ctx.checker.typeToString(expected, provideExpr)}，实际为 ${ctx.checker.typeToString(actual, implementationExpr)}`,
+    file,
+    line,
+    errorCode: "SC2010",
+    docsUrl: "https://supacloud.dev/errors/SC2010"
+  });
+}
+function providerTokenValueType(expr, ctx) {
+  const type = ctx.checker.getTypeAtLocation(expr);
+  const typeArguments = typeArgumentsOf(type, ctx);
+  if (typeArguments.length > 0)
+    return typeArguments[0];
+  if (ts3.isIdentifier(expr)) {
+    const declaration = resolveDeclaration(expr, ctx)[0];
+    if (declaration && ts3.isClassDeclaration(declaration)) {
+      return declaredClassType(declaration, ctx);
+    }
+  }
+  return;
+}
+function providerImplementationType(expr, kind, ctx) {
+  if (kind === "class" || kind === "existing") {
+    if (ts3.isIdentifier(expr)) {
+      const declaration = resolveDeclaration(expr, ctx)[0];
+      if (declaration && ts3.isClassDeclaration(declaration)) {
+        return declaredClassType(declaration, ctx);
+      }
+    }
+    const type = ctx.checker.getTypeAtLocation(expr);
+    const typeArguments = typeArgumentsOf(type, ctx);
+    return typeArguments.length > 0 ? typeArguments[0] : undefined;
+  }
+  if (kind === "factory") {
+    const type = ctx.checker.getTypeAtLocation(expr);
+    const signature = ctx.checker.getSignaturesOfType(type, ts3.SignatureKind.Call)[0];
+    return signature?.getReturnType();
+  }
+  return ctx.checker.getTypeAtLocation(expr);
+}
+function declaredClassType(declaration, ctx) {
+  const name = declaration.name;
+  if (!name)
+    return;
+  const symbol = ctx.checker.getSymbolAtLocation(name);
+  return symbol ? ctx.checker.getDeclaredTypeOfSymbol(symbol) : undefined;
+}
+function typeArgumentsOf(type, ctx) {
+  return isTypeReference(type) ? ctx.checker.getTypeArguments(type) : [];
+}
+function isTypeReference(type) {
+  return "target" in type;
+}
+function isUnknownOrAny(type) {
+  return (type.flags & (ts3.TypeFlags.Any | ts3.TypeFlags.Unknown)) !== 0;
+}
 function parseController(input, ctx) {
   let decl;
-  if (Node.isClassDeclaration(input)) {
+  if (ts3.isClassDeclaration(input)) {
     decl = input;
   } else {
     const unwrapped = unwrapForwardRef(input);
-    const resolved = Node.isIdentifier(unwrapped) ? resolveDeclaration(unwrapped)[0] : undefined;
-    if (resolved && Node.isClassDeclaration(resolved)) {
+    const resolved = ts3.isIdentifier(unwrapped) ? resolveDeclaration(unwrapped, ctx)[0] : undefined;
+    if (resolved && ts3.isClassDeclaration(resolved)) {
       decl = resolved;
     }
   }
@@ -622,46 +1365,46 @@ function parseController(input, ctx) {
     return;
   let path = "/";
   let standalone;
-  const pathArg = controllerDec.getArguments()[0];
+  const pathArg = decoratorArguments(controllerDec)[0];
   if (pathArg) {
-    if (Node.isStringLiteral(pathArg)) {
-      path = pathArg.getLiteralText();
-    } else if (Node.isObjectLiteralExpression(pathArg)) {
+    if (ts3.isStringLiteral(pathArg)) {
+      path = pathArg.text;
+    } else if (ts3.isObjectLiteralExpression(pathArg)) {
       const p = stringLiteralProp(pathArg, "path");
       if (p)
         path = p;
       standalone = booleanProp(pathArg, "standalone");
     }
   }
-  const { deps, optionalDeps, selfDeps, skipSelfDeps, missing } = classDeps(decl, ctx);
-  const file = sourcePath(ctx.rootDir, decl.getSourceFile().getFilePath());
+  const { deps, optionalDeps, selfDeps, skipSelfDeps, hostDeps, functionalInjects, missing } = classDeps(decl, ctx);
+  const file = sourcePath(ctx.rootDir, decl.getSourceFile().fileName);
   if (missing) {
-    warn(ctx, "missing-deps", `controller ${decl.getName()} 的部分构造依赖无法静态解析`, file, decl.getStartLineNumber());
+    warn(ctx, "missing-deps", `controller ${decl.name?.text} 的部分构造依赖无法静态解析`, file, lineOf(decl));
   }
   const injectable = parseInjectableOptions(decl, ctx);
   const routes = [];
   const schemaImports = {};
   const classGuards = [];
-  for (const dec of decl.getDecorators()) {
-    if (decoratorName(dec) === "UseGuards") {
-      for (const gArg of dec.getArguments()) {
-        classGuards.push(tokenText(gArg));
+  for (const dec of decoratorsOf(decl)) {
+    if (decoratorName2(dec) === "UseGuards") {
+      for (const gArg of decoratorArguments(dec)) {
+        classGuards.push(tokenText(gArg, ctx));
       }
     }
   }
-  for (const method of decl.getMethods()) {
-    for (const dec of method.getDecorators()) {
-      const name = decoratorName(dec);
+  for (const method of decl.members.filter(ts3.isMethodDeclaration)) {
+    for (const dec of decoratorsOf(method)) {
+      const name = decoratorName2(dec);
       const httpMethod = name ? ROUTE_DECORATORS[name] : undefined;
       if (!httpMethod)
         continue;
-      const args = dec.getArguments();
+      const args = decoratorArguments(dec);
       const pathArg2 = args[0];
-      const routePath = pathArg2 && Node.isStringLiteral(pathArg2) ? pathArg2.getLiteralText() : "/";
+      const routePath = pathArg2 && ts3.isStringLiteral(pathArg2) ? pathArg2.text : "/";
       const route = {
         method: httpMethod,
         path: routePath,
-        handler: method.getName()
+        handler: propertyName(method.name)
       };
       const pathParams = [];
       const paramRegex = /:([a-zA-Z0-9_]+)/g;
@@ -679,13 +1422,13 @@ function parseController(input, ctx) {
       const queryDefaults = {};
       let hasBodyBinding = false;
       const handlerParams = [];
-      for (const p of method.getParameters()) {
-        const pName = p.getName();
+      for (const p of method.parameters) {
+        const pName = parameterName(p);
         let hasBindingDecorator = false;
         let paramNode;
-        for (const pDec of p.getDecorators()) {
-          const dName = decoratorName(pDec);
-          const dArgs = pDec.getArguments();
+        for (const pDec of decoratorsOf(p)) {
+          const dName = decoratorName2(pDec);
+          const dArgs = decoratorArguments(pDec);
           if (dName === "Param") {
             hasBindingDecorator = true;
             const parsed = parseBindingOptions(dArgs, pName);
@@ -727,7 +1470,7 @@ function parseController(input, ctx) {
         }
         if (!hasBindingDecorator && pathParams.includes(pName)) {
           paramBindings.push(pName);
-          const typeText = p.getType().getText();
+          const typeText = p.type ? nodeText(p.type) : "";
           let inferredTransform;
           if (typeText === "number") {
             paramTransforms[pName] = "number";
@@ -770,37 +1513,37 @@ function parseController(input, ctx) {
         route.handlerParams = handlerParams;
       const routeGuards = [...classGuards];
       const routeCanDeactivate = [];
-      for (const mDec of method.getDecorators()) {
-        const dName = decoratorName(mDec);
-        const mArgs = mDec.getArguments();
+      for (const mDec of decoratorsOf(method)) {
+        const dName = decoratorName2(mDec);
+        const mArgs = decoratorArguments(mDec);
         if (dName === "UseGuards") {
           for (const gArg of mArgs) {
-            routeGuards.push(tokenText(gArg));
+            routeGuards.push(tokenText(gArg, ctx));
           }
         } else if (dName === "CanDeactivate") {
           for (const gArg of mArgs) {
-            routeCanDeactivate.push(tokenText(gArg));
+            routeCanDeactivate.push(tokenText(gArg, ctx));
           }
         } else if (dName === "Title") {
           const tArg = mArgs[0];
-          if (tArg && Node.isStringLiteral(tArg)) {
-            route.title = tArg.getLiteralText();
+          if (tArg && ts3.isStringLiteral(tArg)) {
+            route.title = tArg.text;
           }
         } else if (dName === "Data") {
           const dArg = mArgs[0];
-          if (dArg && Node.isObjectLiteralExpression(dArg)) {
+          if (dArg && ts3.isObjectLiteralExpression(dArg)) {
             route.data = { ...route.data, ...parseObjectLiteralValues(dArg) };
           }
         } else if (dName === "Resolve") {
           const rArg = mArgs[0];
-          if (rArg && Node.isObjectLiteralExpression(rArg)) {
+          if (rArg && ts3.isObjectLiteralExpression(rArg)) {
             const resolvers = route.resolvers ?? {};
-            for (const prop of rArg.getProperties()) {
-              if (Node.isPropertyAssignment(prop)) {
-                const rName = prop.getName();
-                const init = prop.getInitializer();
+            for (const prop of rArg.properties) {
+              if (ts3.isPropertyAssignment(prop)) {
+                const rName = propertyName(prop.name);
+                const init = prop.initializer;
                 if (init)
-                  resolvers[rName] = tokenText(init);
+                  resolvers[rName] = tokenText(init, ctx);
               }
             }
             if (Object.keys(resolvers).length > 0) {
@@ -810,52 +1553,52 @@ function parseController(input, ctx) {
         }
       }
       const optionsArg = args[1];
-      if (optionsArg && Node.isObjectLiteralExpression(optionsArg)) {
+      if (optionsArg && ts3.isObjectLiteralExpression(optionsArg)) {
         for (const field of ["body", "params", "query", "response"]) {
           const schemaExpr = getProp(optionsArg, field);
-          if (schemaExpr && Node.isIdentifier(schemaExpr)) {
-            route[field] = schemaExpr.getText();
+          if (schemaExpr && ts3.isIdentifier(schemaExpr)) {
+            route[field] = nodeText(schemaExpr);
             const importPath = importPathOf(schemaExpr, ctx);
             if (importPath)
-              schemaImports[schemaExpr.getText()] = importPath;
+              schemaImports[schemaExpr.text] = importPath;
           }
         }
         const commandExpr = getProp(optionsArg, "command");
-        if (commandExpr && Node.isIdentifier(commandExpr)) {
-          const commandDecl = resolveDeclaration(commandExpr)[0];
-          route.command = commandDecl && Node.isClassDeclaration(commandDecl) ? commandDecl.getName() ?? commandExpr.getText() : commandExpr.getText();
+        if (commandExpr && ts3.isIdentifier(commandExpr)) {
+          const commandDecl = resolveDeclaration(commandExpr, ctx)[0];
+          route.command = commandDecl && ts3.isClassDeclaration(commandDecl) ? commandDecl.name?.text ?? commandExpr.text : commandExpr.text;
         }
         const guardsExpr = getProp(optionsArg, "guards");
-        if (guardsExpr && Node.isArrayLiteralExpression(guardsExpr)) {
-          for (const el of guardsExpr.getElements()) {
-            routeGuards.push(tokenText(el));
+        if (guardsExpr && ts3.isArrayLiteralExpression(guardsExpr)) {
+          for (const el of guardsExpr.elements) {
+            routeGuards.push(tokenText(el, ctx));
           }
         }
         const canMatchExpr = getProp(optionsArg, "canMatch");
-        if (canMatchExpr && Node.isArrayLiteralExpression(canMatchExpr)) {
+        if (canMatchExpr && ts3.isArrayLiteralExpression(canMatchExpr)) {
           const canMatchList = [];
-          for (const el of canMatchExpr.getElements()) {
-            canMatchList.push(tokenText(el));
+          for (const el of canMatchExpr.elements) {
+            canMatchList.push(tokenText(el, ctx));
           }
           if (canMatchList.length > 0) {
             route.canMatch = canMatchList;
           }
         }
         const canDeactivateExpr = getProp(optionsArg, "canDeactivate");
-        if (canDeactivateExpr && Node.isArrayLiteralExpression(canDeactivateExpr)) {
-          for (const el of canDeactivateExpr.getElements()) {
-            routeCanDeactivate.push(tokenText(el));
+        if (canDeactivateExpr && ts3.isArrayLiteralExpression(canDeactivateExpr)) {
+          for (const el of canDeactivateExpr.elements) {
+            routeCanDeactivate.push(tokenText(el, ctx));
           }
         }
         const resolversExpr = getProp(optionsArg, "resolvers");
-        if (resolversExpr && Node.isObjectLiteralExpression(resolversExpr)) {
+        if (resolversExpr && ts3.isObjectLiteralExpression(resolversExpr)) {
           const resolvers = {};
-          for (const prop of resolversExpr.getProperties()) {
-            if (Node.isPropertyAssignment(prop)) {
-              const rName = prop.getName();
-              const init = prop.getInitializer();
+          for (const prop of resolversExpr.properties) {
+            if (ts3.isPropertyAssignment(prop)) {
+              const rName = propertyName(prop.name);
+              const init = prop.initializer;
               if (init)
-                resolvers[rName] = tokenText(init);
+                resolvers[rName] = tokenText(init, ctx);
             }
           }
           if (Object.keys(resolvers).length > 0) {
@@ -863,24 +1606,27 @@ function parseController(input, ctx) {
           }
         }
         const redirectToExpr = getProp(optionsArg, "redirectTo");
-        if (redirectToExpr && Node.isStringLiteral(redirectToExpr)) {
-          route.redirectTo = redirectToExpr.getLiteralText();
+        if (redirectToExpr && ts3.isStringLiteral(redirectToExpr)) {
+          route.redirectTo = redirectToExpr.text;
         }
         const pathMatchExpr = getProp(optionsArg, "pathMatch");
-        if (pathMatchExpr && Node.isStringLiteral(pathMatchExpr)) {
-          const val = pathMatchExpr.getLiteralText();
+        if (pathMatchExpr && ts3.isStringLiteral(pathMatchExpr)) {
+          const val = pathMatchExpr.text;
           if (val === "full" || val === "prefix") {
             route.pathMatch = val;
           }
         }
         const titleExpr = getProp(optionsArg, "title");
-        if (titleExpr && Node.isStringLiteral(titleExpr)) {
-          route.title = titleExpr.getLiteralText();
+        if (titleExpr && ts3.isStringLiteral(titleExpr)) {
+          route.title = titleExpr.text;
         }
         const dataExpr = getProp(optionsArg, "data");
-        if (dataExpr && Node.isObjectLiteralExpression(dataExpr)) {
+        if (dataExpr && ts3.isObjectLiteralExpression(dataExpr)) {
           route.data = { ...route.data, ...parseObjectLiteralValues(dataExpr) };
         }
+        const aspects = parseAspectRefs(getProp(optionsArg, "aspects"), ctx, `route ${httpMethod} ${routePath}`);
+        if (aspects.length > 0)
+          route.aspects = aspects;
       }
       if (routeGuards.length > 0) {
         route.guards = routeGuards;
@@ -892,46 +1638,40 @@ function parseController(input, ctx) {
     }
   }
   return {
-    className: decl.getName() ?? "<anonymous>",
+    className: decl.name?.text ?? "<anonymous>",
     path,
     scope: injectable?.scope ?? "request",
     deps,
+    hasOnDestroy: hasDestroyHook(decl) || undefined,
     optionalDeps: optionalDeps.length > 0 ? optionalDeps : undefined,
     selfDeps: selfDeps.length > 0 ? selfDeps : undefined,
     skipSelfDeps: skipSelfDeps.length > 0 ? skipSelfDeps : undefined,
+    hostDeps: hostDeps.length > 0 ? hostDeps : undefined,
+    functionalInjects: functionalInjects.length > 0 ? functionalInjects : undefined,
     standalone: standalone || undefined,
     routes,
     file,
-    importPath: modulePath(ctx.rootDir, decl.getSourceFile().getFilePath()),
+    importPath: modulePath(ctx.rootDir, decl.getSourceFile().fileName),
     schemaImports: Object.keys(schemaImports).length > 0 ? schemaImports : undefined
   };
 }
 function classDeps(cls, ctx) {
   const injectable = parseInjectableOptions(cls, ctx);
-  if (injectable?.deps) {
-    return {
-      deps: injectable.deps,
-      optionalDeps: [],
-      selfDeps: [],
-      skipSelfDeps: [],
-      hostDeps: [],
-      missing: false
-    };
-  }
-  const ctor = cls.getConstructors()[0];
-  const deps = [];
+  const ctor = cls.members.find(ts3.isConstructorDeclaration);
+  const deps = injectable?.deps ? [...injectable.deps] : [];
   const optionalDeps = [];
   const selfDeps = [];
   const skipSelfDeps = [];
   const hostDeps = [];
+  const functionalInjects = [];
   let missing = false;
-  if (ctor && ctor.getParameters().length > 0) {
-    const injectParams = parseInjectParams(cls);
+  if (!injectable?.deps && ctor && ctor.parameters.length > 0) {
+    const injectParams = parseInjectParams(cls, ctx);
     const optionalIndices = parseOptionalParams(cls);
     const selfIndices = parseModifierParams(cls, "Self");
     const skipSelfIndices = parseModifierParams(cls, "SkipSelf");
     const hostIndices = parseModifierParams(cls, "Host");
-    ctor.getParameters().forEach((param, index) => {
+    ctor.parameters.forEach((param, index) => {
       const isOptional = optionalIndices.has(index);
       const injected = injectParams.get(index);
       const tokenName = injected ?? paramTypeTokenName(param, ctx);
@@ -951,47 +1691,62 @@ function classDeps(cls, ctx) {
       }
     });
   }
-  for (const prop of cls.getProperties()) {
-    const init = prop.getInitializer();
-    if (init && Node.isCallExpression(init)) {
-      const callName = init.getExpression().getText().split(".").pop();
+  for (const prop of cls.members.filter(ts3.isPropertyDeclaration)) {
+    const init = prop.initializer;
+    if (init && ts3.isCallExpression(init)) {
+      const callName = nodeText(init.expression).split(".").pop();
       if (callName === "inject") {
-        const [tokenArg, optionsArg] = init.getArguments();
+        const [tokenArg, optionsArg] = init.arguments;
         if (tokenArg) {
-          const tokenName = tokenText(tokenArg);
-          if (tokenName) {
-            if (!deps.includes(tokenName))
-              deps.push(tokenName);
-            if (optionsArg && Node.isObjectLiteralExpression(optionsArg)) {
-              const isOptional = booleanProp(optionsArg, "optional");
-              if (isOptional && !optionalDeps.includes(tokenName)) {
-                optionalDeps.push(tokenName);
-              }
-              const isSelf = booleanProp(optionsArg, "self");
-              if (isSelf && !selfDeps.includes(tokenName)) {
-                selfDeps.push(tokenName);
-              }
-              const isSkipSelf = booleanProp(optionsArg, "skipSelf");
-              if (isSkipSelf && !skipSelfDeps.includes(tokenName)) {
-                skipSelfDeps.push(tokenName);
-              }
-              const isHost = booleanProp(optionsArg, "host");
-              if (isHost && !hostDeps.includes(tokenName)) {
-                hostDeps.push(tokenName);
-              }
-            }
+          const tokenName = tokenText(tokenArg, ctx);
+          const unwrappedToken = unwrapForwardRef(tokenArg);
+          const known = ts3.isStringLiteral(unwrappedToken) || ts3.isIdentifier(unwrappedToken) && (ctx.tokensByName.has(tokenName) || ctx.classesByName.has(tokenName));
+          if (!known) {
+            missing = true;
+            continue;
+          }
+          if (!deps.includes(tokenName))
+            deps.push(tokenName);
+          const options = optionsArg && ts3.isObjectLiteralExpression(optionsArg) ? {
+            optional: booleanProp(optionsArg, "optional") ?? false,
+            self: booleanProp(optionsArg, "self") ?? false,
+            skipSelf: booleanProp(optionsArg, "skipSelf") ?? false,
+            host: booleanProp(optionsArg, "host") ?? false
+          } : { optional: false, self: false, skipSelf: false, host: false };
+          if (options.optional && !optionalDeps.includes(tokenName))
+            optionalDeps.push(tokenName);
+          if (options.self && !selfDeps.includes(tokenName))
+            selfDeps.push(tokenName);
+          if (options.skipSelf && !skipSelfDeps.includes(tokenName))
+            skipSelfDeps.push(tokenName);
+          if (options.host && !hostDeps.includes(tokenName))
+            hostDeps.push(tokenName);
+          if (!functionalInjects.some((entry) => entry.token === tokenName)) {
+            functionalInjects.push({
+              token: tokenName,
+              expression: nodeText(unwrappedToken),
+              importPath: ts3.isIdentifier(unwrappedToken) ? (() => {
+                const declaration = resolveDeclaration(unwrappedToken, ctx)[0];
+                return declaration && isProjectSourcePath(declaration.getSourceFile().fileName, ctx.rootDir) ? modulePath(ctx.rootDir, declaration.getSourceFile().fileName) : undefined;
+              })() : undefined,
+              importModule: ts3.isIdentifier(unwrappedToken) ? (() => {
+                const declaration = resolveDeclaration(unwrappedToken, ctx)[0];
+                return declaration && !isProjectSourcePath(declaration.getSourceFile().fileName, ctx.rootDir) ? importModuleOf(unwrappedToken, ctx) : undefined;
+              })() : undefined,
+              ...options
+            });
           }
         }
       }
     }
   }
-  return { deps, optionalDeps, selfDeps, skipSelfDeps, hostDeps, missing };
+  return { deps, optionalDeps, selfDeps, skipSelfDeps, hostDeps, functionalInjects, missing };
 }
 function paramTypeTokenName(param, ctx) {
-  const typeNode = param.getTypeNode();
+  const typeNode = param.type;
   if (!typeNode)
     return;
-  const text = typeNode.getText().replace(/<.*>$/, "").replace(/\[\]$/, "").trim();
+  const text = nodeText(typeNode).replace(/<.*>$/, "").replace(/\[\]$/, "").trim();
   if (ctx.classesByName.has(text))
     return text;
   if (ctx.tokensByName.has(text))
@@ -1009,63 +1764,63 @@ function parseInjectableOptions(cls, ctx) {
   const providedIn = stringLiteralProp(obj, "providedIn");
   const depsExpr = getProp(obj, "deps");
   return {
-    scope: scope && SCOPES.includes(scope) ? scope : undefined,
+    scope: scope && isScope(scope) ? scope : undefined,
     providedIn: providedIn === "root" ? "root" : undefined,
-    deps: depsExpr ? arrayProp(obj, "deps").map((el) => ctx ? tokenNameOf(el, ctx).name : el.getText()) : undefined
+    deps: depsExpr ? arrayProp(obj, "deps").map((el) => ctx ? tokenNameOf(el, ctx).name : nodeText(el)) : undefined
   };
 }
-function parseInjectParams(cls) {
+function parseInjectParams(cls, ctx) {
   const result = new Map;
-  const ctor = cls.getConstructors()[0];
+  const ctor = cls.members.find(ts3.isConstructorDeclaration);
   if (!ctor)
     return result;
-  ctor.getParameters().forEach((param, index) => {
-    for (const dec of param.getDecorators()) {
-      if (decoratorName(dec) !== "Inject")
+  ctor.parameters.forEach((param, index) => {
+    for (const dec of decoratorsOf(param)) {
+      if (decoratorName2(dec) !== "Inject")
         continue;
-      const arg = dec.getArguments()[0];
+      const arg = decoratorArguments(dec)[0];
       if (arg)
-        result.set(index, tokenText(arg));
+        result.set(index, tokenText(arg, ctx));
     }
   });
   return result;
 }
 function parseOptionalParams(cls) {
   const result = new Set;
-  const ctor = cls.getConstructors()[0];
+  const ctor = cls.members.find(ts3.isConstructorDeclaration);
   if (!ctor)
     return result;
-  ctor.getParameters().forEach((param, index) => {
-    for (const dec of param.getDecorators()) {
-      if (decoratorName(dec) === "Optional")
+  ctor.parameters.forEach((param, index) => {
+    for (const dec of decoratorsOf(param)) {
+      if (decoratorName2(dec) === "Optional")
         result.add(index);
     }
-    if (param.hasQuestionToken())
+    if (param.questionToken)
       result.add(index);
   });
   return result;
 }
 function parseModifierParams(cls, modifierName) {
   const result = new Set;
-  const ctor = cls.getConstructors()[0];
+  const ctor = cls.members.find(ts3.isConstructorDeclaration);
   if (!ctor)
     return result;
-  ctor.getParameters().forEach((param, index) => {
-    for (const dec of param.getDecorators()) {
-      if (decoratorName(dec) === modifierName)
+  ctor.parameters.forEach((param, index) => {
+    for (const dec of decoratorsOf(param)) {
+      if (decoratorName2(dec) === modifierName)
         result.add(index);
     }
   });
   return result;
 }
 function unwrapForwardRef(expr) {
-  if (Node.isCallExpression(expr)) {
-    const exprText = expr.getExpression().getText();
+  if (ts3.isCallExpression(expr)) {
+    const exprText = nodeText(expr.expression);
     if (exprText === "forwardRef" || exprText.endsWith(".forwardRef")) {
-      const arg = expr.getArguments()[0];
-      if (arg && (Node.isArrowFunction(arg) || Node.isFunctionExpression(arg))) {
-        const body = arg.getBody();
-        if (body && Node.isExpression(body)) {
+      const arg = expr.arguments[0];
+      if (arg && (ts3.isArrowFunction(arg) || ts3.isFunctionExpression(arg))) {
+        const body = arg.body;
+        if (body && ts3.isExpression(body)) {
           return unwrapForwardRef(body);
         }
       }
@@ -1073,18 +1828,18 @@ function unwrapForwardRef(expr) {
   }
   return expr;
 }
-function tokenText(expr) {
+function tokenText(expr, ctx) {
   const unwrapped = unwrapForwardRef(expr);
-  if (Node.isStringLiteral(unwrapped))
-    return unwrapped.getLiteralText();
-  if (Node.isIdentifier(unwrapped)) {
-    const decl = resolveDeclaration(unwrapped)[0];
-    if (decl && Node.isClassDeclaration(decl))
-      return decl.getName() ?? unwrapped.getText();
-    if (decl && Node.isVariableDeclaration(decl))
-      return decl.getName();
+  if (ts3.isStringLiteral(unwrapped))
+    return unwrapped.text;
+  if (ts3.isIdentifier(unwrapped)) {
+    const decl = resolveDeclaration(unwrapped, ctx)[0];
+    if (decl && ts3.isClassDeclaration(decl))
+      return decl.name?.text ?? unwrapped.text;
+    if (decl && ts3.isVariableDeclaration(decl))
+      return variableName(decl);
   }
-  return unwrapped.getText();
+  return nodeText(unwrapped);
 }
 function resolveScope(input, ctx) {
   if (input.explicit)
@@ -1101,98 +1856,181 @@ function resolveScope(input, ctx) {
 }
 function tokenNameOf(expr, ctx) {
   const unwrapped = unwrapForwardRef(expr);
-  if (Node.isIdentifier(unwrapped)) {
-    const decl = resolveDeclaration(unwrapped)[0];
-    if (decl && Node.isClassDeclaration(decl)) {
-      return { name: decl.getName() ?? expr.getText(), kind: "class" };
+  if (ts3.isIdentifier(unwrapped)) {
+    const decl = resolveDeclaration(unwrapped, ctx)[0];
+    if (decl && ts3.isClassDeclaration(decl)) {
+      return { name: decl.name?.text ?? nodeText(expr), kind: "class" };
     }
-    if (decl && Node.isVariableDeclaration(decl)) {
-      const name = decl.getName();
+    if (decl && ts3.isVariableDeclaration(decl)) {
+      const name = variableName(decl);
       return { name, kind: ctx.tokensByName.has(name) ? "injection-token" : "class" };
     }
-    if (ctx.tokensByName.has(expr.getText())) {
-      return { name: expr.getText(), kind: "injection-token" };
+    if (ctx.tokensByName.has(unwrapped.text)) {
+      return { name: unwrapped.text, kind: "injection-token" };
     }
   }
-  return { name: expr.getText(), kind: "class" };
+  return { name: nodeText(expr), kind: "class" };
 }
-function resolveDeclaration(id) {
-  let symbol = id.getSymbol();
+function resolveDeclaration(id, ctx) {
+  let symbol = ctx.checker.getSymbolAtLocation(id);
   if (!symbol)
     return [];
-  let declarations = symbol.getDeclarations();
+  let declarations = symbol.declarations ?? [];
   for (let guard = 0;guard < 4; guard += 1) {
-    const isAlias = declarations.some((d) => Node.isImportSpecifier(d) || Node.isImportClause(d) || Node.isNamespaceImport(d));
+    const isAlias = declarations.some((d) => ts3.isImportSpecifier(d) || ts3.isImportClause(d) || ts3.isNamespaceImport(d));
     if (!isAlias)
       break;
-    const aliased = symbol.getAliasedSymbol();
-    if (!aliased)
+    if (!(symbol.flags & ts3.SymbolFlags.Alias))
       break;
+    const aliased = ctx.checker.getAliasedSymbol(symbol);
     symbol = aliased;
-    declarations = aliased.getDeclarations();
+    declarations = aliased.declarations ?? [];
   }
   return declarations;
 }
 function importPathOf(id, ctx) {
-  const symbol = id.getSymbol();
-  const first = symbol?.getDeclarations()[0];
-  if (first && (Node.isImportSpecifier(first) || Node.isImportClause(first))) {
-    const importDecl = first.getFirstAncestorByKind(SyntaxKind.ImportDeclaration);
-    const target = importDecl?.getModuleSpecifierSourceFile();
-    if (target)
-      return modulePath(ctx.rootDir, target.getFilePath());
-  }
-  const decl = resolveDeclaration(id)[0];
+  const decl = resolveDeclaration(id, ctx)[0];
   if (decl)
-    return modulePath(ctx.rootDir, decl.getSourceFile().getFilePath());
+    return modulePath(ctx.rootDir, decl.getSourceFile().fileName);
+  return;
+}
+function importModuleOf(id, ctx) {
+  const symbol = ctx.checker.getSymbolAtLocation(id);
+  const declarations = symbol?.declarations ?? [];
+  for (const declaration of declarations) {
+    let current = declaration;
+    while (current) {
+      if (ts3.isImportDeclaration(current)) {
+        const moduleSpecifier = current.moduleSpecifier;
+        return ts3.isStringLiteral(moduleSpecifier) ? moduleSpecifier.text : undefined;
+      }
+      current = current.parent;
+    }
+  }
   return;
 }
 function findDecorator(cls, name) {
-  return cls.getDecorators().find((dec) => decoratorName(dec) === name);
+  return decoratorsOf(cls).find((dec) => decoratorName2(dec) === name);
 }
-function decoratorName(dec) {
-  const expr = dec.getExpression();
-  if (Node.isCallExpression(expr)) {
-    return expr.getExpression().getText().split(".").pop();
+function decoratorName2(dec) {
+  const expr = dec.expression;
+  if (ts3.isCallExpression(expr)) {
+    return nodeText(expr.expression).split(".").pop();
   }
-  if (Node.isIdentifier(expr))
-    return expr.getText();
+  if (ts3.isIdentifier(expr))
+    return expr.text;
   return;
 }
 function decoratorObjectArg(dec) {
-  const expr = dec.getExpression();
-  if (!Node.isCallExpression(expr))
+  const expr = dec.expression;
+  if (!ts3.isCallExpression(expr))
     return;
-  const arg = expr.getArguments()[0];
-  return arg && Node.isObjectLiteralExpression(arg) ? arg : undefined;
+  const arg = expr.arguments[0];
+  return arg && ts3.isObjectLiteralExpression(arg) ? arg : undefined;
 }
 function getProp(obj, name) {
-  const prop = obj.getProperty(name);
-  if (prop && Node.isPropertyAssignment(prop))
-    return prop.getInitializer();
+  const prop = obj.properties.find((item) => (ts3.isPropertyAssignment(item) || ts3.isShorthandPropertyAssignment(item)) && propertyName(item.name) === name);
+  if (!prop)
+    return;
+  if (ts3.isPropertyAssignment(prop))
+    return prop.initializer;
+  if (ts3.isShorthandPropertyAssignment(prop))
+    return prop.name;
   return;
 }
+function toCompilerDiagnostic(diagnostic, rootDir) {
+  const file = diagnostic.file;
+  const position = file && diagnostic.start !== undefined ? file.getLineAndCharacterOfPosition(diagnostic.start) : undefined;
+  return {
+    severity: diagnostic.category === ts3.DiagnosticCategory.Error ? "error" : "warn",
+    code: `typescript-${diagnostic.code}`,
+    errorCode: `TS${diagnostic.code}`,
+    message: ts3.flattenDiagnosticMessageText(diagnostic.messageText, `
+`),
+    file: file ? sourcePath(rootDir, file.fileName) : undefined,
+    line: position ? position.line + 1 : undefined
+  };
+}
 function stringLiteralProp(obj, name) {
   const expr = getProp(obj, name);
-  return expr && Node.isStringLiteral(expr) ? expr.getLiteralText() : undefined;
+  return expr && ts3.isStringLiteral(expr) ? expr.text : undefined;
 }
 function arrayProp(obj, name) {
   const expr = getProp(obj, name);
-  return expr && Node.isArrayLiteralExpression(expr) ? expr.getElements() : [];
+  return expr && ts3.isArrayLiteralExpression(expr) ? [...expr.elements] : [];
+}
+function parseAspectRefs(expression, ctx, owner) {
+  if (!expression)
+    return [];
+  if (!ts3.isArrayLiteralExpression(expression)) {
+    ctx.diagnostics.push({
+      severity: "error",
+      code: "dynamic-aspect-reference",
+      message: `${owner} 的 aspects 必须是显式数组字面量，并且每一项必须是可解析的函数引用`,
+      file: sourcePath(ctx.rootDir, expression.getSourceFile().fileName),
+      line: lineOf(expression),
+      suggestion: "使用 aspects: [auditAspect, transactionAspect]，不要使用变量、调用表达式或字符串 pointcut。",
+      errorCode: "SC4010",
+      docsUrl: "https://supacloud.dev/errors/SC4010"
+    });
+    return [];
+  }
+  const refs = [];
+  for (const element of expression.elements) {
+    if (ts3.isSpreadElement(element) || !ts3.isIdentifier(element)) {
+      ctx.diagnostics.push({
+        severity: "error",
+        code: "dynamic-aspect-reference",
+        message: `${owner} 的 aspects 只能包含显式的函数标识符引用，无法静态编译 '${nodeText(element)}'`,
+        file: sourcePath(ctx.rootDir, element.getSourceFile().fileName),
+        line: lineOf(element),
+        suggestion: "将 aspect 直接写入数组，例如 aspects: [auditAspect]。",
+        errorCode: "SC4010",
+        docsUrl: "https://supacloud.dev/errors/SC4010"
+      });
+      continue;
+    }
+    const declaration = resolveDeclaration(element, ctx).find((candidate) => ts3.isFunctionDeclaration(candidate) || ts3.isVariableDeclaration(candidate) && candidate.initializer !== undefined && (ts3.isArrowFunction(candidate.initializer) || ts3.isFunctionExpression(candidate.initializer)));
+    if (!declaration) {
+      ctx.diagnostics.push({
+        severity: "error",
+        code: "invalid-aspect-reference",
+        message: `${owner} 引用了 '${element.text}'，但它不是可静态解析的 aspect 函数`,
+        file: sourcePath(ctx.rootDir, element.getSourceFile().fileName),
+        line: lineOf(element),
+        suggestion: "aspect 必须是函数声明、箭头函数或函数表达式的直接引用。",
+        errorCode: "SC4011",
+        docsUrl: "https://supacloud.dev/errors/SC4011"
+      });
+      continue;
+    }
+    const name = ts3.isFunctionDeclaration(declaration) ? declaration.name?.text : ts3.isVariableDeclaration(declaration) ? variableName(declaration) : undefined;
+    if (!name)
+      continue;
+    const declaredFile = declaration.getSourceFile().fileName;
+    const projectLocal = isProjectSourcePath(declaredFile, ctx.rootDir);
+    refs.push({
+      name,
+      expression: element.text,
+      importPath: projectLocal ? modulePath(ctx.rootDir, declaredFile) : undefined,
+      importModule: projectLocal ? undefined : importModuleOf(element, ctx)
+    });
+  }
+  return refs;
 }
 function booleanProp(obj, name) {
   const expr = getProp(obj, name);
   if (!expr)
     return;
-  if (expr.getKind() === SyntaxKind.TrueKeyword)
+  if (expr.kind === ts3.SyntaxKind.TrueKeyword)
     return true;
-  if (expr.getKind() === SyntaxKind.FalseKeyword)
+  if (expr.kind === ts3.SyntaxKind.FalseKeyword)
     return false;
   return;
 }
 function parseScopeProp(obj) {
   const scope = stringLiteralProp(obj, "scope");
-  return scope && SCOPES.includes(scope) ? scope : undefined;
+  return scope && isScope(scope) ? scope : undefined;
 }
 function parseBindingOptions(args, defaultName) {
   let name = defaultName;
@@ -1200,16 +2038,16 @@ function parseBindingOptions(args, defaultName) {
   let defaultValue;
   const first = args[0];
   const second = args[1];
-  if (first && Node.isStringLiteral(first)) {
-    name = first.getLiteralText();
-  } else if (first && Node.isObjectLiteralExpression(first)) {
+  if (first && ts3.isStringLiteral(first)) {
+    name = first.text;
+  } else if (first && ts3.isObjectLiteralExpression(first)) {
     const nameProp = getProp(first, "name");
-    if (nameProp && Node.isStringLiteral(nameProp)) {
-      name = nameProp.getLiteralText();
+    if (nameProp && ts3.isStringLiteral(nameProp)) {
+      name = nameProp.text;
     }
     const trProp = getProp(first, "transform");
-    if (trProp && Node.isStringLiteral(trProp)) {
-      const val = trProp.getLiteralText();
+    if (trProp && ts3.isStringLiteral(trProp)) {
+      const val = trProp.text;
       if (val === "number" || val === "boolean" || val === "string") {
         transform = val;
       }
@@ -1219,10 +2057,10 @@ function parseBindingOptions(args, defaultName) {
       defaultValue = parseLiteralValue(defProp);
     }
   }
-  if (second && Node.isObjectLiteralExpression(second)) {
+  if (second && ts3.isObjectLiteralExpression(second)) {
     const trProp = getProp(second, "transform");
-    if (trProp && Node.isStringLiteral(trProp)) {
-      const val = trProp.getLiteralText();
+    if (trProp && ts3.isStringLiteral(trProp)) {
+      const val = trProp.text;
       if (val === "number" || val === "boolean" || val === "string") {
         transform = val;
       }
@@ -1235,28 +2073,28 @@ function parseBindingOptions(args, defaultName) {
   return { name, transform, default: defaultValue };
 }
 function parseLiteralValue(node) {
-  if (Node.isStringLiteral(node))
-    return node.getLiteralText();
-  if (Node.isNumericLiteral(node))
-    return node.getLiteralValue();
-  if (node.getKindName() === "TrueKeyword")
+  if (ts3.isStringLiteral(node))
+    return node.text;
+  if (ts3.isNumericLiteral(node))
+    return Number(node.text);
+  if (node.kind === ts3.SyntaxKind.TrueKeyword)
     return true;
-  if (node.getKindName() === "FalseKeyword")
+  if (node.kind === ts3.SyntaxKind.FalseKeyword)
     return false;
-  if (Node.isArrayLiteralExpression(node)) {
-    return node.getElements().map(parseLiteralValue);
+  if (ts3.isArrayLiteralExpression(node)) {
+    return node.elements.map(parseLiteralValue);
   }
-  if (Node.isObjectLiteralExpression(node)) {
+  if (ts3.isObjectLiteralExpression(node)) {
     return parseObjectLiteralValues(node);
   }
   return;
 }
 function parseObjectLiteralValues(obj) {
   const result = {};
-  for (const prop of obj.getProperties()) {
-    if (Node.isPropertyAssignment(prop)) {
-      const name = prop.getName();
-      const init = prop.getInitializer();
+  for (const prop of obj.properties) {
+    if (ts3.isPropertyAssignment(prop)) {
+      const name = propertyName(prop.name);
+      const init = prop.initializer;
       if (init) {
         result[name] = parseLiteralValue(init);
       }
@@ -1275,7 +2113,8 @@ function warn(ctx, code, message, file, line) {
 }
 
 // src/generate.ts
-import { mkdir, rename, unlink, writeFile } from "node:fs/promises";
+import { createHash as createHash4 } from "node:crypto";
+import { access, mkdir, rename, unlink, writeFile } from "node:fs/promises";
 import { join as join2 } from "node:path";
 
 // src/util.ts
@@ -1354,6 +2193,7 @@ var INTERFACES = `export interface CompiledRoute {
   queryDefaults?: Record<string, unknown>;
   title?: string;
   data?: Record<string, unknown>;
+  aspects?: CompiledAspect[];
   invoker?: (
     controller: unknown,
     request: {
@@ -1374,8 +2214,33 @@ export interface CompiledCommand {
   audit?: string;
   idempotency: "required" | "none";
   standalone?: boolean;
+  aspects?: CompiledAspect[];
+}
+
+export interface CompiledJob {
+  className: string;
+  name: string;
+  serviceKey: string;
+  scope: "application" | "request" | "job";
+  aspects?: CompiledAspect[];
 }
 
+export interface CompiledAspectContext {
+  kind: "route" | "command" | "job";
+  name: string;
+  input: unknown;
+  request?: Request;
+  requestContext?: unknown;
+  scope?: Record<string, unknown>;
+  services?: Record<string, unknown>;
+  metadata?: unknown;
+}
+
+export type CompiledAspect = (
+  context: CompiledAspectContext,
+  next: () => unknown | Promise<unknown>,
+) => unknown | Promise<unknown>;
+
 export interface CompiledController {
   path: string;
   serviceKey: string;
@@ -1394,13 +2259,62 @@ export interface CompiledModule {
     ctx: unknown,
     imported?: Record<string, Record<string, unknown>>,
   ): Record<string, unknown>;
+  destroyRequestScope?(scope: Record<string, unknown>): Promise<void>;
   createJobScope?(
     services: Record<string, unknown>,
     ctx: unknown,
     imported?: Record<string, Record<string, unknown>>,
   ): Record<string, unknown>;
+  destroyJobScope?(scope: Record<string, unknown>): Promise<void>;
   controllers: CompiledController[];
   commands: CompiledCommand[];
+  jobs: CompiledJob[];
+  aspects?: CompiledAspect[];
+}`;
+var TYPE_GUARDS = `function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isFunction(value: unknown): value is (...args: unknown[]) => unknown {
+  return typeof value === "function";
+}
+
+function resolveFactoryValue(value: unknown): unknown {
+  if (!isRecord(value) || !isFunction(value.factory)) return undefined;
+  return value.factory();
+}
+
+const scopeDestructions = new WeakMap<object, Promise<void>>();
+
+function destroyScopeInstances(
+  scope: Record<string, unknown>,
+  plan: readonly { key: string; index?: number }[],
+): Promise<void> {
+  const pending = scopeDestructions.get(scope);
+  if (pending) return pending;
+  const destruction = Promise.resolve().then(async () => {
+    const errors: unknown[] = [];
+    const seen = new Set<unknown>();
+    for (const entry of [...plan].reverse()) {
+      const value = scope[entry.key];
+      const instance = entry.index === undefined ? value
+        : Array.isArray(value) ? value[entry.index] : undefined;
+      if (seen.has(instance)) continue;
+      seen.add(instance);
+      try {
+        if (isRecord(instance) && isFunction(instance.onDestroy)) {
+          await instance.onDestroy();
+        } else if (isRecord(instance) && isFunction(instance.ngOnDestroy)) {
+          await instance.ngOnDestroy();
+        }
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length > 0) throw new AggregateError(errors, "Scope destruction failed");
+  });
+  scopeDestructions.set(scope, destruction);
+  return destruction;
 }`;
 function renderApplication(graph, options) {
   let modules = topoSortModules(graph.modules);
@@ -1418,6 +2332,8 @@ function renderApplication(graph, options) {
           referencedTokens.add(d);
         for (const d of ctrl.skipSelfDeps ?? [])
           referencedTokens.add(d);
+        for (const d of ctrl.hostDeps ?? [])
+          referencedTokens.add(d);
       }
       for (const p of mod.providers) {
         for (const d of p.deps ?? [])
@@ -1428,6 +2344,8 @@ function renderApplication(graph, options) {
           referencedTokens.add(d);
         for (const d of p.skipSelfDeps ?? [])
           referencedTokens.add(d);
+        for (const d of p.hostDeps ?? [])
+          referencedTokens.add(d);
         if (p.useExisting)
           referencedTokens.add(p.useExisting);
       }
@@ -1452,6 +2370,8 @@ function renderApplication(graph, options) {
     ...imports.size > 0 ? [""] : [],
     INTERFACES,
     "",
+    TYPE_GUARDS,
+    "",
     "export function createCompiledModules(): CompiledModule[] {",
     "  return [",
     ...descriptorEntries.map((entry) => indent(entry, 4) + ","),
@@ -1459,29 +2379,33 @@ function renderApplication(graph, options) {
     "}",
     "",
     "export async function initializeApplication(services: Record<string, unknown>): Promise<void> {",
-    '  const initializers = (services.appInitializer ?? (services as any)["supacloud.app-initializer"]) as unknown;',
-    "  if (Array.isArray(initializers)) {",
-    "    for (const init of initializers) {",
-    '      if (typeof init === "function") await init();',
+    '  const initializers = [services.environmentInitializer ?? services["supacloud.environment-initializer"], services.appInitializer ?? services["supacloud.app-initializer"]];',
+    "  for (const group of initializers) {",
+    "    if (Array.isArray(group)) {",
+    "      for (const init of group) {",
+    "        if (isFunction(init)) await init();",
+    "      }",
+    "    } else if (isFunction(group)) {",
+    "      await group();",
     "    }",
-    '  } else if (typeof initializers === "function") {',
-    "    await (initializers as () => unknown)();",
     "  }",
     "}",
     "",
     "export async function destroyApplication(services: Record<string, unknown>): Promise<void> {",
-    '  const destroyRef = (services.destroyRef ?? (services as any)["supacloud.destroy-ref"]) as { destroy?: () => Promise<void>; _teardowns?: Array<() => void | Promise<void>> } | undefined;',
-    '  if (destroyRef && typeof destroyRef.destroy === "function") {',
+    '  const destroyRef = services.destroyRef ?? services["supacloud.destroy-ref"];',
+    "  if (isRecord(destroyRef) && isFunction(destroyRef.destroy)) {",
     "    await destroyRef.destroy();",
-    "  } else if (destroyRef && Array.isArray(destroyRef._teardowns)) {",
+    "  } else if (isRecord(destroyRef) && Array.isArray(destroyRef._teardowns)) {",
     "    for (const teardown of [...destroyRef._teardowns].reverse()) {",
-    '      if (typeof teardown === "function") await teardown();',
+    "      if (isFunction(teardown)) await teardown();",
     "    }",
     "  }",
     "  const instances = Object.values(services);",
     "  for (const inst of instances.reverse()) {",
-    '    if (inst && typeof (inst as any).onDestroy === "function") {',
-    "      await (inst as any).onDestroy();",
+    "    if (isRecord(inst) && isFunction(inst.onDestroy)) {",
+    "      await inst.onDestroy();",
+    "    } else if (isRecord(inst) && isFunction(inst.ngOnDestroy)) {",
+    "      await inst.ngOnDestroy();",
     "    }",
     "  }",
     "}",
@@ -1510,21 +2434,39 @@ async function generateApplication(graph, options) {
   await mkdir(options.outDir, { recursive: true });
   const applicationPath = join2(options.outDir, "application.ts");
   const manifestPath = join2(options.outDir, "app.manifest.json");
-  await writeFileAtomic(applicationPath, rendered.applicationCode);
-  await writeFileAtomic(manifestPath, rendered.manifestJson);
-  const written = [applicationPath, manifestPath];
+  const written = [];
+  if (await writeFileIfChanged(applicationPath, rendered.applicationCode, options.artifactHashes)) {
+    written.push(applicationPath);
+  }
+  if (await writeFileIfChanged(manifestPath, rendered.manifestJson, options.artifactHashes)) {
+    written.push(manifestPath);
+  }
   if (rendered.clientCode) {
     const clientPath = join2(options.outDir, "client.ts");
-    await writeFileAtomic(clientPath, rendered.clientCode);
-    written.push(clientPath);
+    if (await writeFileIfChanged(clientPath, rendered.clientCode, options.artifactHashes)) {
+      written.push(clientPath);
+    }
   }
   if (rendered.permissionsCode) {
     const permissionsPath = join2(options.outDir, "permissions.ts");
-    await writeFileAtomic(permissionsPath, rendered.permissionsCode);
-    written.push(permissionsPath);
+    if (await writeFileIfChanged(permissionsPath, rendered.permissionsCode, options.artifactHashes)) {
+      written.push(permissionsPath);
+    }
   }
   return written;
 }
+async function writeFileIfChanged(path, content, hashes) {
+  const hash = createHash4("sha1").update(content).digest("hex");
+  if (hashes?.get(path) === hash) {
+    try {
+      await access(path);
+      return false;
+    } catch {}
+  }
+  await writeFileAtomic(path, content);
+  hashes?.set(path, hash);
+  return true;
+}
 async function writeFileAtomic(path, content) {
   const temporaryPath = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
   try {
@@ -1575,11 +2517,13 @@ class ImportManager {
   get size() {
     return this.entries.size;
   }
-  add(exported, importPath) {
-    if (!importPath)
+  add(exported, importPath, importModule) {
+    const path = importModule ?? importPath;
+    const packageImport = importModule !== undefined;
+    if (!path)
       return exported;
     for (const [local2, entry] of this.entries) {
-      if (entry.path === importPath && entry.exported === exported)
+      if (entry.path === path && entry.exported === exported && entry.package === packageImport)
         return local2;
     }
     let local = exported;
@@ -1588,18 +2532,18 @@ class ImportManager {
       local = `${exported}${counter}`;
       counter += 1;
     }
-    this.entries.set(local, { path: importPath, exported });
+    this.entries.set(local, { path, exported, package: packageImport });
     return local;
   }
   render(rootDir, outDir) {
     const byPath = new Map;
     for (const [local, entry] of this.entries) {
-      const list = byPath.get(entry.path) ?? [];
+      const spec = entry.package ? entry.path : relativeImportPath(outDir, join2(rootDir, `${entry.path}.ts`));
+      const list = byPath.get(spec) ?? [];
       list.push({ exported: entry.exported, local });
-      byPath.set(entry.path, list);
+      byPath.set(spec, list);
     }
-    return [...byPath.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([path, symbols]) => {
-      const spec = relativeImportPath(outDir, join2(rootDir, `${path}.ts`));
+    return [...byPath.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([spec, symbols]) => {
       const names = symbols.sort((a, b) => a.exported.localeCompare(b.exported)).map((s) => s.local === s.exported ? s.exported : `${s.exported} as ${s.local}`).join(", ");
       return `import { ${names} } from "${spec}";`;
     });
@@ -1621,14 +2565,19 @@ class ModuleGenerator {
     this.module = module;
     this.imports = imports;
     this.pascal = pascalName(module.name);
+    if (module.providers.some((provider) => (provider.functionalInjects?.length ?? 0) > 0) || module.controllers.some((controller) => (controller.functionalInjects?.length ?? 0) > 0)) {
+      imports.add("runInInjectionContext", undefined, "@supacloud/app");
+    }
   }
   renderFactories() {
     const sections = [this.renderServicesFactory()];
     if (this.hasFactoryContent("request")) {
       sections.push(this.renderScopeFactory("request"));
+      sections.push(this.renderScopeDestroyer("request"));
     }
     if (this.hasFactoryContent("job")) {
       sections.push(this.renderScopeFactory("job"));
+      sections.push(this.renderScopeDestroyer("job"));
     }
     return sections;
   }
@@ -1640,12 +2589,18 @@ class ModuleGenerator {
     ];
     if (this.hasFactoryContent("request")) {
       lines.push(`  createRequestScope: create${this.pascal}RequestScope,`);
+      lines.push(`  destroyRequestScope: destroy${this.pascal}RequestScope,`);
     }
     if (this.hasFactoryContent("job")) {
       lines.push(`  createJobScope: create${this.pascal}JobScope,`);
+      lines.push(`  destroyJobScope: destroy${this.pascal}JobScope,`);
     }
     lines.push(`  controllers: ${this.renderControllers()},`);
-    lines.push(`  commands: ${JSON.stringify(this.module.commands)},`);
+    lines.push(`  commands: ${this.renderCommands()},`);
+    lines.push(`  jobs: ${this.renderJobs()},`);
+    if (this.module.aspects && this.module.aspects.length > 0) {
+      lines.push(`  aspects: ${this.renderAspects(this.module.aspects)},`);
+    }
     lines.push(`}`);
     return lines.join(`
 `);
@@ -1708,6 +2663,9 @@ class ModuleGenerator {
         if (route.data && Object.keys(route.data).length > 0) {
           fields.push(`data: ${JSON.stringify(route.data)}`);
         }
+        if (route.aspects && route.aspects.length > 0) {
+          fields.push(`aspects: ${this.renderAspects(route.aspects)}`);
+        }
         const invokerArgs = (route.handlerParams ?? []).map((hp) => {
           if (hp.kind === "param") {
             const accessor = `req.params?.[${JSON.stringify(hp.bindingName ?? hp.name)}]`;
@@ -1746,7 +2704,7 @@ class ModuleGenerator {
           return "undefined";
         });
         const callArgs = invokerArgs.length > 0 ? invokerArgs.join(", ") : "req";
-        fields.push(`invoker: async (ctrl: any, req: any) => await (ctrl as any).${route.handler}(${callArgs})`);
+        fields.push(`invoker: async (ctrl: unknown, req: { params?: Record<string, unknown>; query?: Record<string, unknown>; body?: unknown; headers?: Record<string, unknown>; context?: unknown }) => { ` + `if (!isRecord(ctrl)) throw new TypeError("Route controller is not an object"); ` + `const handler = ctrl[${JSON.stringify(route.handler)}]; ` + `if (typeof handler !== "function") throw new TypeError("Route handler ${route.handler} is not callable"); ` + `return await Reflect.apply(handler, ctrl, [${callArgs}]); }`);
         return `{ ${fields.join(", ")} }`;
       });
       return [
@@ -1763,6 +2721,32 @@ class ModuleGenerator {
 ${indent(item, 2)}`).join(",")}
 ]`;
   }
+  renderCommands() {
+    if (this.module.commands.length === 0)
+      return "[]";
+    return `[${this.module.commands.map((command) => {
+      const fields = [
+        `className: ${JSON.stringify(command.className)}`,
+        `name: ${JSON.stringify(command.name)}`,
+        `permission: ${JSON.stringify(command.permission ?? "")}`,
+        `transaction: ${JSON.stringify(command.transaction)}`,
+        ...command.audit ? [`audit: ${JSON.stringify(command.audit)}`] : [],
+        `idempotency: ${JSON.stringify(command.idempotency)}`,
+        ...command.standalone ? ["standalone: true"] : [],
+        ...command.aspects && command.aspects.length > 0 ? [`aspects: ${this.renderAspects(command.aspects)}`] : []
+      ];
+      return `{ ${fields.join(", ")} }`;
+    }).join(", ")}]`;
+  }
+  renderJobs() {
+    const jobs = this.module.jobs ?? [];
+    if (jobs.length === 0)
+      return "[]";
+    return `[${jobs.map((job) => `{ className: ${JSON.stringify(job.className)}, name: ${JSON.stringify(job.name)}, serviceKey: ${JSON.stringify(camelName(job.className))}, scope: ${JSON.stringify(job.scope)},${job.aspects && job.aspects.length > 0 ? ` aspects: ${this.renderAspects(job.aspects)},` : ""} }`).join(", ")}]`;
+  }
+  renderAspects(aspects) {
+    return `[${aspects.map((aspect) => this.imports.add(aspect.name, aspect.importPath, aspect.importModule)).join(", ")}]`;
+  }
   renderServicesFactory() {
     return [
       `function create${this.pascal}Services(`,
@@ -1785,6 +2769,30 @@ ${indent(item, 2)}`).join(",")}
       indent(this.renderFactoryBody(kind), 2),
       `}`
     ].join(`
+`);
+  }
+  renderScopeDestroyer(kind) {
+    const suffix = kind === "request" ? "RequestScope" : "JobScope";
+    const plan = [];
+    const multiIndices = new Map;
+    for (const provider of orderProviders(this.module.providers.filter((p) => factoryOfScope(p.scope) === kind))) {
+      const index = provider.multi ? multiIndices.get(provider.token) ?? 0 : undefined;
+      if (index !== undefined)
+        multiIndices.set(provider.token, index + 1);
+      if (provider.kind !== "existing" && provider.hasOnDestroy) {
+        plan.push({ key: camelName(provider.token), index });
+      }
+    }
+    for (const controller of this.module.controllers) {
+      if (factoryOfScope(controller.scope) === kind && controller.hasOnDestroy) {
+        plan.push({ key: camelName(controller.className) });
+      }
+    }
+    return [
+      `async function destroy${this.pascal}${suffix}(scope: Record<string, unknown>): Promise<void> {`,
+      `  await destroyScopeInstances(scope, ${JSON.stringify(plan)});`,
+      `}`
+    ].join(`
 `);
   }
   renderFactoryBody(kind) {
@@ -1825,39 +2833,76 @@ ${indent(item, 2)}`).join(",")}
     const key = camelName(provider.token);
     switch (provider.kind) {
       case "class": {
-        const useClass = this.imports.add(provider.useClass ?? provider.token, provider.importPath);
-        const args = provider.deps.map((dep) => this.depExpr(dep, kind, provider.optionalDeps?.includes(dep))).join(", ");
+        const useClass = this.imports.add(provider.useClass ?? provider.token, provider.importPath, provider.importModule);
+        const args = provider.deps.map((dep) => this.depExpr(dep, kind, this.depOptions(provider, dep))).join(", ");
         const local = this.localVar(isMulti ? provider.useClass ?? `${provider.token}Item` : provider.token, kind);
-        return { constLine: `const ${local} = new ${useClass}(${args});`, key, expr: local };
+        return {
+          constLine: `const ${local} = ${this.instantiate(useClass, args, kind, provider.functionalInjects)};`,
+          key,
+          expr: local
+        };
       }
       case "value": {
-        const expr = provider.importPath ? this.imports.add(provider.useValueExpr ?? "undefined", provider.importPath) : provider.useValueExpr ?? "undefined";
+        const expr = provider.importPath || provider.importModule ? this.imports.add(provider.useValueExpr ?? "undefined", provider.importPath, provider.importModule) : provider.useValueExpr ?? "undefined";
         const local = this.localVar(isMulti ? `${provider.token}Item` : provider.token, kind);
         return { constLine: `const ${local} = ${expr};`, key, expr: local };
       }
       case "factory": {
         if (provider.tokenKind === "injection-token" && !provider.useFactoryName) {
-          const tokenIdent = this.imports.add(provider.token, provider.importPath);
+          const tokenIdent = this.imports.add(provider.token, provider.importPath, provider.importModule);
           const local2 = this.localVar(isMulti ? `${provider.token}Item` : provider.token, kind);
-          const constLine = `const ${local2} = typeof ${tokenIdent} === "object" && ${tokenIdent} && "factory" in ${tokenIdent} && typeof (${tokenIdent} as any).factory === "function" ? (${tokenIdent} as any).factory() : undefined;`;
+          const constLine = `const ${local2} = resolveFactoryValue(${tokenIdent});`;
           return { constLine, key, expr: local2 };
         }
-        const factory = this.imports.add(provider.useFactoryName ?? "", provider.importPath);
-        const args = provider.deps.map((dep) => this.depExpr(dep, kind, provider.optionalDeps?.includes(dep))).join(", ");
+        const factory = this.imports.add(provider.useFactoryName ?? "", provider.importPath, provider.importModule);
+        const args = provider.deps.map((dep) => this.depExpr(dep, kind, this.depOptions(provider, dep))).join(", ");
         const local = this.localVar(isMulti ? provider.useFactoryName ?? `${provider.token}Item` : provider.token, kind);
         return { constLine: `const ${local} = ${factory}(${args});`, key, expr: local };
       }
       case "existing": {
-        return { key, expr: this.depExpr(provider.useExisting ?? provider.token, kind, provider.optionalDeps?.includes(provider.token)) };
+        return {
+          key,
+          expr: this.depExpr(provider.useExisting ?? provider.token, kind, this.depOptions(provider, provider.useExisting ?? provider.token))
+        };
       }
     }
   }
   emitController(controller, kind) {
     const className = this.imports.add(controller.className, controller.importPath);
-    const args = controller.deps.map((dep) => this.depExpr(dep, kind, controller.optionalDeps?.includes(dep))).join(", ");
+    const args = controller.deps.map((dep) => this.depExpr(dep, kind, this.depOptions(controller, dep))).join(", ");
     const key = camelName(controller.className);
     const local = this.localVar(controller.className, kind);
-    return { constLine: `const ${local} = new ${className}(${args});`, key, expr: local };
+    return {
+      constLine: `const ${local} = ${this.instantiate(className, args, kind, controller.functionalInjects)};`,
+      key,
+      expr: local
+    };
+  }
+  instantiate(className, args, kind, functionalInjects) {
+    if (!functionalInjects || functionalInjects.length === 0) {
+      return `new ${className}(${args})`;
+    }
+    const clauses = functionalInjects.map((entry) => {
+      const token = this.imports.add(entry.expression, entry.importPath, entry.importModule);
+      const value = this.depExpr(entry.token, kind, {
+        optional: entry.optional,
+        self: entry.self,
+        skipSelf: entry.skipSelf,
+        host: entry.host
+      });
+      return `if (token === ${token}) return ${value} as T;`;
+    });
+    const missing = `if (options?.optional) return undefined; throw new Error("Static inject token not available: " + String(token));`;
+    const injector = [
+      `{`,
+      `get<T>(token: unknown, options?: { optional?: boolean; self?: boolean; skipSelf?: boolean; host?: boolean }): T | undefined {`,
+      ...clauses,
+      missing,
+      `},`,
+      `}`
+    ].join(`
+`);
+    return `runInInjectionContext(${injector}, () => new ${className}(${args}))`;
   }
   localVar(token, kind) {
     const locals = this.locals[kind];
@@ -1874,23 +2919,34 @@ ${indent(item, 2)}`).join(",")}
     locals.set(token, local);
     return local;
   }
-  depExpr(token, kind, isOptional = false) {
+  depOptions(node, token) {
+    return {
+      optional: node.optionalDeps?.includes(token) ?? false,
+      self: node.selfDeps?.includes(token) ?? false,
+      skipSelf: node.skipSelfDeps?.includes(token) ?? false,
+      host: "hostDeps" in node ? node.hostDeps?.includes(token) ?? false : false
+    };
+  }
+  depExpr(token, kind, options = {}) {
+    const isOptional = options.optional ?? false;
+    const isSelf = options.self ?? false;
+    const isSkipSelf = options.skipSelf ?? false;
     if (kind === "request" && isRequestContextToken(token, this.graph.tokenNames))
       return "ctx";
     if (kind === "job" && isJobContextToken(token, this.graph.tokenNames))
       return "ctx";
     const own = this.module.providers.find((p) => p.token === token);
-    if (own) {
+    const ownIsLocal = own && factoryOfScope(own.scope) === kind;
+    if (own && ownIsLocal && !isSkipSelf) {
       if (factoryOfScope(own.scope) === kind && own.kind !== "existing") {
         return this.locals[kind].get(token) ?? camelName(token);
       }
-      if (own.kind === "existing" && factoryOfScope(own.scope) === kind) {
-        return this.depExpr(own.useExisting ?? token, kind, isOptional);
-      }
-      if (kind === "services") {
-        return `services.${camelName(token)}`;
+      if (own.kind === "existing") {
+        return this.depExpr(own.useExisting ?? token, kind, options);
       }
-      return `services.${camelName(token)}`;
+    }
+    if (isSelf) {
+      return isOptional ? "undefined" : `services.${camelName(token)}`;
     }
     for (const importName of this.module.imports) {
       const imported = this.graph.modules.find((m) => m.name === importName);
@@ -1909,6 +2965,8 @@ ${indent(item, 2)}`).join(",")}
     if (isOptional && !this.graph.externalTokens.includes(token)) {
       return "undefined";
     }
+    if (isSelf)
+      return isOptional ? "undefined" : `services.${camelName(token)}`;
     if (kind === "services")
       return isOptional ? `(deps.${camelName(token)} ?? undefined)` : `deps.${camelName(token)}`;
     return isOptional ? `(services.${camelName(token)} ?? undefined)` : `services.${camelName(token)}`;
@@ -2366,12 +3424,16 @@ var COMPILER_DIAGNOSTIC_CODES = {
   "conflicting-route-method": { code: "SC3018", docsUrl: "https://supacloud.dev/errors/SC3018" },
   "missing-param-colon": { code: "SC3019", docsUrl: "https://supacloud.dev/errors/SC3019" },
   "missing-token-factory": { code: "SC2009", docsUrl: "https://supacloud.dev/errors/SC2009" },
+  "provider-type-mismatch": { code: "SC2010", docsUrl: "https://supacloud.dev/errors/SC2010" },
+  "unsupported-provider-helper": { code: "SC2011", docsUrl: "https://supacloud.dev/errors/SC2011" },
   "command-missing-permission": { code: "SC4001", docsUrl: "https://supacloud.dev/errors/SC4001" },
   "duplicate-command": { code: "SC4002", docsUrl: "https://supacloud.dev/errors/SC4002" },
   "route-command-unresolved": { code: "SC4003", docsUrl: "https://supacloud.dev/errors/SC4003" },
   "command-governance-unsupported": { code: "SC4004", docsUrl: "https://supacloud.dev/errors/SC4004" },
   "route-command-binding-disabled": { code: "SC4005", docsUrl: "https://supacloud.dev/errors/SC4005" },
   "command-transaction-readonly": { code: "SC4006", docsUrl: "https://supacloud.dev/errors/SC4006" },
+  "dynamic-aspect-reference": { code: "SC4010", docsUrl: "https://supacloud.dev/errors/SC4010" },
+  "invalid-aspect-reference": { code: "SC4011", docsUrl: "https://supacloud.dev/errors/SC4011" },
   "unused-root-provider": { code: "SC5001", docsUrl: "https://supacloud.dev/errors/SC5001" }
 };
 function validateGraph(graph, options = false) {
@@ -2405,10 +3467,14 @@ function validateGraph(graph, options = false) {
       }
     }
   }
-  function resolveDep(module, token) {
-    const own = module.providers.find((p) => p.token === token);
-    if (own)
-      return { module, provider: own };
+  function resolveDep(module, token, flags = {}) {
+    if (!flags.skipSelf) {
+      const own = module.providers.find((p) => p.token === token);
+      if (own)
+        return { module, provider: own };
+    }
+    if (flags.self)
+      return;
     for (const importName of module.imports) {
       const imported = graph.modules.find((m) => m.name === importName);
       if (!imported || !imported.exports.includes(token))
@@ -2606,7 +3672,7 @@ function validateGraph(graph, options = false) {
       }
       if (controller.selfDeps && controller.selfDeps.length > 0) {
         for (const dep of controller.selfDeps) {
-          const own = module.providers.find((p) => p.token === dep);
+          const own = module.providers.find((p) => p.token === dep && p.scope === controller.scope);
           if (!own) {
             error("self-resolution-failed", `模块 ${module.name} 的 controller ${controller.className} 参数标记了 @Self()，但 ${dep} 未在当前模块内部提供`, controller.file, undefined, `Provide '${dep}' in module '${module.name}' or remove @Self().`);
           }
@@ -2614,7 +3680,7 @@ function validateGraph(graph, options = false) {
       }
       if (controller.skipSelfDeps && controller.skipSelfDeps.length > 0) {
         for (const dep of controller.skipSelfDeps) {
-          const own = module.providers.find((p) => p.token === dep);
+          const own = module.providers.find((p) => p.token === dep && p.scope === controller.scope);
           if (own) {
             error("skip-self-resolution-failed", `模块 ${module.name} 的 controller ${controller.className} 参数标记了 @SkipSelf()，但 ${dep} 在当前模块内部声明了 provider`, controller.file, undefined, `Remove '${dep}' from module '${module.name}' providers or remove @SkipSelf().`);
           }
@@ -2689,7 +3755,7 @@ function validateGraph(graph, options = false) {
     for (const provider of module.providers) {
       if (provider.selfDeps && provider.selfDeps.length > 0) {
         for (const dep of provider.selfDeps) {
-          const own = module.providers.find((p) => p.token === dep);
+          const own = module.providers.find((p) => p.token === dep && p.scope === provider.scope);
           if (!own) {
             error("self-resolution-failed", `模块 ${module.name} 的 provider ${provider.token} 参数标记了 @Self()，但 ${dep} 未在当前模块内部提供`, provider.file, provider.line, `Provide '${dep}' in module '${module.name}' or remove @Self().`);
           }
@@ -2697,7 +3763,7 @@ function validateGraph(graph, options = false) {
       }
       if (provider.skipSelfDeps && provider.skipSelfDeps.length > 0) {
         for (const dep of provider.skipSelfDeps) {
-          const own = module.providers.find((p) => p.token === dep);
+          const own = module.providers.find((p) => p.token === dep && p.scope === provider.scope);
           if (own) {
             error("skip-self-resolution-failed", `模块 ${module.name} 的 provider ${provider.token} 参数标记了 @SkipSelf()，但 ${dep} 在当前模块内部声明了 provider`, provider.file, provider.line, `Remove '${dep}' from module '${module.name}' providers or remove @SkipSelf().`);
           }
@@ -2705,7 +3771,10 @@ function validateGraph(graph, options = false) {
       }
       for (const dep of provider.deps) {
         const isOptional = provider.optionalDeps?.includes(dep);
-        const resolved = resolveDep(module, dep);
+        const resolved = resolveDep(module, dep, {
+          self: provider.selfDeps?.includes(dep),
+          skipSelf: provider.skipSelfDeps?.includes(dep)
+        });
         if (!resolved) {
           if (isOptional) {
             continue;
@@ -2713,6 +3782,8 @@ function validateGraph(graph, options = false) {
           if (!graph.externalTokens.includes(dep)) {
             if (globalProviders.has(dep)) {
               const owner = globalProviders.get(dep);
+              if (!owner)
+                continue;
               error("module-boundary", `模块 ${module.name} 的 provider ${provider.token} 依赖 ${dep}，该 token 由模块 ${owner.module.name} 提供但未被 import`, provider.file, provider.line, `Import module '${owner.module.name}' in '${module.name}', add '${dep}' to '${owner.module.name}' exports, or mark @Injectable({ providedIn: 'root' }).`);
             } else if (dep.includes("TOKEN") || dep.endsWith("Token") || dep.length > 2 && dep === dep.toUpperCase()) {
               error("missing-token-factory", `InjectionToken '${dep}' referenced by provider '${provider.token}' has no provider in module '${module.name}' and no default factory function.`, provider.file, provider.line, `Provide '${dep}' in @Module({ providers: [...] }) or declare it with new InjectionToken('${dep}', { factory: () => ... }).`);
@@ -2773,7 +3844,8 @@ function validateGraph(graph, options = false) {
             }
           }
           if (rule.onlyDependOnLibsWithTags && rule.onlyDependOnLibsWithTags.length > 0) {
-            const hasAllowed = targetTags.some((t) => rule.onlyDependOnLibsWithTags.includes(t));
+            const allowedTags = rule.onlyDependOnLibsWithTags;
+            const hasAllowed = targetTags.some((t) => allowedTags.includes(t));
             if (!hasAllowed && targetTags.length > 0) {
               error("module-boundary-violation", `模块 ${module.name} (tags: [${sourceTags.join(", ")}]) 仅允许依赖带有 [${rule.onlyDependOnLibsWithTags.join(", ")}] 标签的模块，但模块 ${targetModule.name} 的标签为 [${targetTags.join(", ")}]`, module.file, module.line);
             }
@@ -2795,6 +3867,8 @@ function validateGraph(graph, options = false) {
         referencedTokens.add(d);
       for (const d of ctrl.skipSelfDeps ?? [])
         referencedTokens.add(d);
+      for (const d of ctrl.hostDeps ?? [])
+        referencedTokens.add(d);
     }
     for (const p of mod.providers) {
       for (const d of p.deps ?? [])
@@ -2805,6 +3879,8 @@ function validateGraph(graph, options = false) {
         referencedTokens.add(d);
       for (const d of p.skipSelfDeps ?? [])
         referencedTokens.add(d);
+      for (const d of p.hostDeps ?? [])
+        referencedTokens.add(d);
       if (p.useExisting)
         referencedTokens.add(p.useExisting);
     }
@@ -2927,7 +4003,10 @@ function detectCycles(graph, resolveDep) {
     state.set(id, "visiting");
     stack.push(ref);
     for (const dep of ref.provider.deps) {
-      const resolved = resolveDep(ref.module, dep);
+      const resolved = resolveDep(ref.module, dep, {
+        self: ref.provider.selfDeps?.includes(dep),
+        skipSelf: ref.provider.skipSelfDeps?.includes(dep)
+      });
       if (resolved)
         visit(resolved);
     }
@@ -3040,6 +4119,8 @@ function detectOrphanModules(graph) {
   }
   while (queue.length > 0) {
     const current = queue.shift();
+    if (!current)
+      continue;
     const mod = moduleMap.get(current);
     if (!mod)
       continue;
@@ -3068,10 +4149,225 @@ function detectOrphanModules(graph) {
 }
 
 // src/compile.ts
-import { existsSync as existsSync2, readFileSync } from "node:fs";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+
+// src/type-safety.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join3, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+import * as ts4 from "@typescript/typescript6";
+var DEFAULT_EXCLUDES = [
+  "**/*.test.ts",
+  "**/*.spec.ts",
+  "**/test/**",
+  "**/tests/**",
+  "**/__tests__/**",
+  "**/fixtures/**",
+  "**/generated/**",
+  "**/dist/**",
+  "**/*.d.ts"
+];
+var DIAGNOSTIC_META = {
+  "generated-any": { errorCode: "SC6001", docsUrl: "https://supacloud.dev/errors/SC6001" },
+  "source-any": { errorCode: "SC6002", docsUrl: "https://supacloud.dev/errors/SC6002" },
+  "source-type-assertion": { errorCode: "SC6003", docsUrl: "https://supacloud.dev/errors/SC6003" },
+  "source-non-null-assertion": { errorCode: "SC6004", docsUrl: "https://supacloud.dev/errors/SC6004" },
+  "source-implicit-widening": { errorCode: "SC6005", docsUrl: "https://supacloud.dev/errors/SC6005" }
+};
+function scanGeneratedArtifacts(artifacts, strict = true) {
+  const diagnostics = [];
+  for (const [file, content] of Object.entries(artifacts)) {
+    if (content === undefined)
+      continue;
+    const sourceFile = ts4.createSourceFile(file, content, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TS);
+    for (const node of descendantsOfKind2(sourceFile, isAnyKeyword)) {
+      diagnostics.push(makeDiagnostic("generated-any", `生成产物 ${file} 包含 any；严格生成模式要求使用 unknown、具体接口或泛型约束。`, sourceFile, node, strict));
+    }
+  }
+  return diagnostics;
+}
+function scanProductionSource(options) {
+  const rootDir = resolve2(options.rootDir);
+  const configPath = join3(rootDir, "tsconfig.json");
+  const projectConfig = existsSync2(configPath) ? readProjectConfig2(configPath) : {
+    options: {
+      strict: true,
+      skipLibCheck: true,
+      target: ts4.ScriptTarget.ES2022,
+      module: ts4.ModuleKind.ESNext
+    },
+    errors: []
+  };
+  const include = options.include ?? ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"];
+  const rootNames = ts4.sys.readDirectory(rootDir, [".ts", ".tsx", ".mts", ".cts"], ["node_modules", "dist"], include).filter((file) => isProductionSourcePath(rootDir, file, [...DEFAULT_EXCLUDES, ...options.exclude ?? []]));
+  const compilerOptions = { ...projectConfig.options, noEmit: true };
+  const host = ts4.createCompilerHost(compilerOptions);
+  host.getCurrentDirectory = () => rootDir;
+  const program = ts4.createProgram(rootNames, compilerOptions, host);
+  const outDir = options.outDir ? normalizeRelative(rootDir, options.outDir) : undefined;
+  const excludes = [...DEFAULT_EXCLUDES, ...options.exclude ?? []];
+  const sourceFiles = program.getSourceFiles().filter((sourceFile) => isProductionSource(rootDir, sourceFile, excludes, outDir));
+  const diagnostics = [...projectConfig.errors, ...program.getOptionsDiagnostics()].map((diagnostic) => ({
+    severity: "error",
+    code: "source-config",
+    message: ts4.flattenDiagnosticMessageText(diagnostic.messageText, `
+`),
+    file: diagnostic.file ? normalizeRelative(rootDir, diagnostic.file.fileName) : normalizeRelative(rootDir, configPath),
+    line: diagnostic.file && diagnostic.start !== undefined ? diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start).line + 1 : undefined,
+    errorCode: `TS${diagnostic.code}`
+  }));
+  const checker = program.getTypeChecker();
+  for (const sourceFile of sourceFiles) {
+    scanSourceFile(sourceFile, checker, rootDir, diagnostics, options.strict ?? false);
+  }
+  return diagnostics;
+}
+function scanSourceFile(sourceFile, checker, rootDir, diagnostics, strict) {
+  for (const node of descendantsOfKind2(sourceFile, isAnyKeyword)) {
+    diagnostics.push(makeDiagnostic("source-any", "生产源码使用了显式 any；请改用 unknown、具体接口或泛型约束。", sourceFile, node, strict, rootDir));
+  }
+  for (const node of descendants(sourceFile)) {
+    if (ts4.isAsExpression(node)) {
+      if (ts4.isAsExpression(node.parent) || ts4.isTypeAssertionExpression(node.parent))
+        continue;
+      const assertedType = node.type.getText(sourceFile);
+      if (assertedType === "const")
+        continue;
+      diagnostics.push(makeDiagnostic("source-type-assertion", `生产源码包含类型断言 ${node.getText(sourceFile)}；请优先使用类型守卫、satisfies 或显式边界解析。`, sourceFile, node, strict, rootDir));
+    } else if (ts4.isTypeAssertionExpression(node)) {
+      if (ts4.isAsExpression(node.parent) || ts4.isTypeAssertionExpression(node.parent))
+        continue;
+      diagnostics.push(makeDiagnostic("source-type-assertion", `生产源码包含类型断言 ${node.getText(sourceFile)}；请优先使用类型守卫、satisfies 或显式边界解析。`, sourceFile, node, strict, rootDir));
+    } else if (ts4.isNonNullExpression(node)) {
+      diagnostics.push(makeDiagnostic("source-non-null-assertion", `生产源码包含非空断言 ${node.getText(sourceFile)}；请显式处理 null/undefined。`, sourceFile, node, strict, rootDir));
+    }
+  }
+  for (const declaration of descendantsOfKind2(sourceFile, ts4.isVariableDeclaration)) {
+    const initializer = declaration.initializer;
+    if (!initializer || declaration.type)
+      continue;
+    const declarationType = checker.getTypeAtLocation(declaration.name);
+    const initializerType = checker.getTypeAtLocation(initializer);
+    for (const name of bindingNames(declaration.name)) {
+      if (isAnyType(checker.getTypeAtLocation(name))) {
+        diagnostics.push(makeDiagnostic("source-any", "生产源码中的变量被推断为 any；请为边界数据提供解析类型或显式 unknown。", sourceFile, name, strict, rootDir));
+      }
+    }
+    if (isAnyType(declarationType))
+      continue;
+    if (isLetDeclaration(declaration) && isLiteralSyntax(initializer) && !isLiteralType(declarationType)) {
+      diagnostics.push(makeDiagnostic("source-implicit-widening", `变量 ${declaration.name.getText(sourceFile)} 的字面量类型从 ${checker.typeToString(initializerType, initializer)} 隐式宽化为 ${checker.typeToString(declarationType, declaration)}；请补充类型或使用 const。`, sourceFile, declaration, strict, rootDir));
+    }
+    if (ts4.isObjectLiteralExpression(initializer) && isConstDeclaration(declaration) && initializer.getText(sourceFile).length > 0 && initializer.properties.some((property) => ts4.isPropertyAssignment(property) && property.initializer !== undefined && !ts4.isAsExpression(property.initializer) && isLiteralExpression(property.initializer))) {
+      diagnostics.push(makeDiagnostic("source-implicit-widening", `常量对象 ${declaration.name.getText(sourceFile)} 的字面量属性会隐式宽化；请补充对象类型或使用 as const。`, sourceFile, declaration, strict, rootDir));
+    }
+  }
+  for (const parameter of descendantsOfKind2(sourceFile, ts4.isParameter)) {
+    if (parameter.type)
+      continue;
+    for (const name of bindingNames(parameter.name)) {
+      if (isAnyType(checker.getTypeAtLocation(name))) {
+        diagnostics.push(makeDiagnostic("source-any", "生产源码中的参数被推断为 any；请补充参数类型。", sourceFile, name, strict, rootDir));
+      }
+    }
+  }
+}
+function readProjectConfig2(configPath) {
+  const config = ts4.readConfigFile(configPath, (file) => readFileSync2(file, "utf8"));
+  if (config.error)
+    return { options: {}, errors: [config.error] };
+  const parsed = ts4.parseJsonConfigFileContent(config.config, ts4.sys, dirname2(configPath));
+  return { options: parsed.options, errors: parsed.errors };
+}
+function isProductionSource(rootDir, sourceFile, excludes, outDir) {
+  const relativePath = normalizeRelative(rootDir, sourceFile.fileName);
+  if (sourceFile.isDeclarationFile || relativePath.startsWith("../") || relativePath.includes("node_modules/"))
+    return false;
+  if (outDir && (relativePath === outDir || relativePath.startsWith(`${outDir}/`)))
+    return false;
+  return !excludes.some((pattern) => globMatches(relativePath, pattern));
+}
+function isProductionSourcePath(rootDir, filePath, excludes) {
+  const relativePath = normalizeRelative(rootDir, filePath);
+  return !relativePath.startsWith("../") && !relativePath.includes("node_modules/") && !excludes.some((pattern) => globMatches(relativePath, pattern));
+}
+function globMatches(value, pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, "§/").replace(/\*\*/g, "§§").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/§\//g, "(?:.*/)?").replace(/§§/g, ".*");
+  return new RegExp(`^${escaped}$`).test(value);
+}
+function bindingNames(name) {
+  if (ts4.isIdentifier(name))
+    return [name];
+  return name.elements.flatMap((element) => ts4.isBindingElement(element) ? bindingNames(element.name) : []);
+}
+function isLiteralExpression(node) {
+  if (!node)
+    return false;
+  return [
+    ts4.SyntaxKind.StringLiteral,
+    ts4.SyntaxKind.NumericLiteral,
+    ts4.SyntaxKind.TrueKeyword,
+    ts4.SyntaxKind.FalseKeyword
+  ].includes(node.kind);
+}
+function isLiteralSyntax(node) {
+  return ts4.isStringLiteral(node) || ts4.isNumericLiteral(node) || node.kind === ts4.SyntaxKind.TrueKeyword || node.kind === ts4.SyntaxKind.FalseKeyword;
+}
+function isLiteralType(type) {
+  return (type.flags & (ts4.TypeFlags.StringLiteral | ts4.TypeFlags.NumberLiteral | ts4.TypeFlags.BooleanLiteral | ts4.TypeFlags.BigIntLiteral)) !== 0;
+}
+function isAnyType(type) {
+  return (type.flags & ts4.TypeFlags.Any) !== 0;
+}
+function isLetDeclaration(declaration) {
+  return ts4.isVariableDeclarationList(declaration.parent) && (declaration.parent.flags & ts4.NodeFlags.Let) !== 0;
+}
+function isConstDeclaration(declaration) {
+  return ts4.isVariableDeclarationList(declaration.parent) && (declaration.parent.flags & ts4.NodeFlags.Const) !== 0;
+}
+function descendants(root) {
+  const result = [];
+  const visit = (node) => {
+    result.push(node);
+    ts4.forEachChild(node, visit);
+  };
+  ts4.forEachChild(root, visit);
+  return result;
+}
+function descendantsOfKind2(root, predicate) {
+  const result = [];
+  const visit = (node) => {
+    if (predicate(node))
+      result.push(node);
+    ts4.forEachChild(node, visit);
+  };
+  ts4.forEachChild(root, visit);
+  return result;
+}
+function makeDiagnostic(code, message, fileOrSourceFile, node, strict, rootDir) {
+  const sourceFile = typeof fileOrSourceFile === "string" ? undefined : fileOrSourceFile;
+  const file = typeof fileOrSourceFile === "string" ? fileOrSourceFile : rootDir ? normalizeRelative(rootDir, fileOrSourceFile.fileName) : fileOrSourceFile.fileName;
+  const meta = DIAGNOSTIC_META[code];
+  return {
+    severity: strict ? "error" : "warn",
+    code,
+    message,
+    file,
+    line: sourceFile ? sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1 : undefined,
+    errorCode: meta.errorCode,
+    docsUrl: meta.docsUrl
+  };
+}
+function normalizeRelative(rootDir, filePath) {
+  return relative2(rootDir, filePath).split(sep2).join("/").replace(/^\.\//, "");
+}
+function isAnyKeyword(node) {
+  return node.kind === ts4.SyntaxKind.AnyKeyword;
+}
+
+// src/compile.ts
 async function compileProject(options) {
-  const graph = await analyzeProject(options.rootDir, options.include, options.cache);
+  const graph = await analyzeProject(options.rootDir, options.include, options.cache, options.changedPaths);
   const diagnostics = [
     ...graph.diagnostics ?? [],
     ...validateGraph(graph, {
@@ -3090,14 +4386,40 @@ async function compileProject(options) {
         diagnostic.severity = "error";
     }
   }
-  const hasErrors = diagnostics.some((diagnostic) => diagnostic.severity === "error");
-  const written = !hasErrors || options.writeOnError !== false ? await generateApplication(graph, {
+  const typeSafety = resolveTypeSafety(options);
+  const rendered = renderApplication(graph, {
     rootDir: options.rootDir,
     outDir: options.outDir,
     generateClient: options.generateClient,
     generatePermissions: options.generatePermissions,
     treeShakeUnusedProviders: options.treeShakeUnusedProviders
-  }) : [];
+  });
+  if (typeSafety.scanProductionSource) {
+    diagnostics.push(...scanProductionSource({
+      rootDir: options.rootDir,
+      include: options.include,
+      outDir: options.outDir,
+      strict: options.strict,
+      ...typeSafety
+    }));
+  }
+  if (typeSafety.noAnyInGenerated) {
+    diagnostics.push(...scanGeneratedArtifacts({
+      "application.ts": rendered.applicationCode,
+      "client.ts": rendered.clientCode,
+      "permissions.ts": rendered.permissionsCode
+    }, options.strict ?? false));
+  }
+  const hasErrors = diagnostics.some((diagnostic) => diagnostic.severity === "error");
+  const generatedOptions = {
+    rootDir: options.rootDir,
+    outDir: options.outDir,
+    generateClient: options.generateClient,
+    generatePermissions: options.generatePermissions,
+    treeShakeUnusedProviders: options.treeShakeUnusedProviders,
+    artifactHashes: options.cache?.generatedHashes
+  };
+  const written = !hasErrors || options.writeOnError !== false ? await generateApplication(graph, generatedOptions) : [];
   const stats = graph.cacheStats ? {
     cacheHit: graph.cacheStats.reanalyzedModules.length === 0,
     changedFiles: [],
@@ -3108,7 +4430,7 @@ async function compileProject(options) {
   return { diagnostics, graph, written, stats };
 }
 async function checkProject(options) {
-  const graph = await analyzeProject(options.rootDir, options.include, options.cache);
+  const graph = await analyzeProject(options.rootDir, options.include, options.cache, options.changedPaths);
   const diagnostics = [
     ...graph.diagnostics ?? [],
     ...validateGraph(graph, {
@@ -3127,6 +4449,7 @@ async function checkProject(options) {
         diagnostic.severity = "error";
     }
   }
+  const typeSafety = resolveTypeSafety(options);
   const rendered = renderApplication(graph, {
     rootDir: options.rootDir,
     outDir: options.outDir,
@@ -3134,6 +4457,22 @@ async function checkProject(options) {
     generatePermissions: options.generatePermissions,
     treeShakeUnusedProviders: options.treeShakeUnusedProviders
   });
+  if (typeSafety.scanProductionSource) {
+    diagnostics.push(...scanProductionSource({
+      rootDir: options.rootDir,
+      include: options.include,
+      outDir: options.outDir,
+      strict: options.strict,
+      ...typeSafety
+    }));
+  }
+  if (typeSafety.noAnyInGenerated) {
+    diagnostics.push(...scanGeneratedArtifacts({
+      "application.ts": rendered.applicationCode,
+      "client.ts": rendered.clientCode,
+      "permissions.ts": rendered.permissionsCode
+    }, options.strict ?? false));
+  }
   const expectedFiles = {
     "application.ts": rendered.applicationCode,
     "app.manifest.json": rendered.manifestJson
@@ -3146,12 +4485,12 @@ async function checkProject(options) {
   }
   const mismatches = [];
   for (const [filename, expectedContent] of Object.entries(expectedFiles)) {
-    const diskPath = join3(options.outDir, filename);
-    if (!existsSync2(diskPath)) {
+    const diskPath = join4(options.outDir, filename);
+    if (!existsSync3(diskPath)) {
       mismatches.push(`${filename}: generated artifact is missing from disk`);
       continue;
     }
-    const diskContent = readFileSync(diskPath, "utf8");
+    const diskContent = readFileSync3(diskPath, "utf8");
     if (diskContent !== expectedContent) {
       mismatches.push(`${filename}: disk artifact differs from current compiler output`);
     }
@@ -3163,10 +4502,17 @@ async function checkProject(options) {
     graph
   };
 }
+function resolveTypeSafety(options) {
+  return {
+    noAnyInGenerated: options.typeSafety?.noAnyInGenerated ?? options.strict ?? false,
+    scanProductionSource: options.typeSafety?.scanProductionSource ?? options.strict ?? false,
+    exclude: options.typeSafety?.exclude
+  };
+}
 
 // src/inspect.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join5 } from "node:path";
 function formatGraph(graph) {
   const lines = [];
   for (const module of graph.modules) {
@@ -3207,13 +4553,13 @@ function doctorProject(rootDir, outDir, graph, upToDate, diagnostics = []) {
   const checks = [
     {
       name: "project-root",
-      ok: existsSync3(rootDir),
-      detail: existsSync3(rootDir) ? rootDir : `missing: ${rootDir}`
+      ok: existsSync4(rootDir),
+      detail: existsSync4(rootDir) ? rootDir : `missing: ${rootDir}`
     },
     {
       name: "tsconfig",
-      ok: existsSync3(join4(rootDir, "tsconfig.json")),
-      detail: existsSync3(join4(rootDir, "tsconfig.json")) ? "tsconfig.json found" : "tsconfig.json missing"
+      ok: existsSync4(join5(rootDir, "tsconfig.json")),
+      detail: existsSync4(join5(rootDir, "tsconfig.json")) ? "tsconfig.json found" : "tsconfig.json missing"
     },
     {
       name: "modules",
@@ -3303,27 +4649,31 @@ function exportGraphDot(graph) {
 
 // src/watch.ts
 import { watch } from "node:fs";
-import { relative as relative3, resolve as resolve2 } from "node:path";
+import { relative as relative4, resolve as resolve4 } from "node:path";
 
 // src/incremental.ts
-import { createHash as createHash2 } from "node:crypto";
-import { access, readdir, readFile } from "node:fs/promises";
-import { relative as relative2, resolve, sep as sep2 } from "node:path";
+import { createHash as createHash5 } from "node:crypto";
+import { access as access2, readdir, readFile } from "node:fs/promises";
+import { isAbsolute, relative as relative3, resolve as resolve3, sep as sep3 } from "node:path";
 function createDependencyGraphCache() {
   return {
     modules: new Map,
-    fileHashes: new Map
+    fileHashes: new Map,
+    generatedHashes: new Map
   };
 }
 function createIncrementalCompiler() {
   let previousSnapshot;
   let previousResult;
+  let previousCache;
   const cache = createDependencyGraphCache();
   return {
     async compile(options, changedPaths) {
-      const snapshot = changedPaths && previousSnapshot ? await updateSnapshot(previousSnapshot, options, changedPaths) : await createSnapshot(options);
+      const optionsKey = optionsKeyOf(options);
+      const snapshot = changedPaths && previousSnapshot && previousSnapshot.optionsKey === optionsKey ? await updateSnapshot(previousSnapshot, options, changedPaths) : await createSnapshot(options);
       const changedFiles = changedPaths && previousSnapshot ? diffFiles(previousSnapshot.files, snapshot.files) : diffFiles(previousSnapshot?.files, snapshot.files);
-      const cacheHit = Boolean(previousSnapshot && previousSnapshot.optionsKey === snapshot.optionsKey && changedFiles.length === 0);
+      const activeCache = options.cache ?? cache;
+      const cacheHit = Boolean(previousSnapshot && previousSnapshot.optionsKey === snapshot.optionsKey && previousCache === activeCache && changedFiles.length === 0);
       if (cacheHit && previousResult) {
         return {
           ...previousResult,
@@ -3336,22 +4686,14 @@ function createIncrementalCompiler() {
           }
         };
       }
-      if (previousResult && previousSnapshot && changedFiles.length > 0 && !await requiresGraphRebuild(options.rootDir, changedFiles)) {
-        const stats2 = {
-          cacheHit: true,
-          changedFiles,
-          affectedModules: findAffectedModules(previousResult.graph.modules, previousResult.graph.modules, changedFiles),
-          reusedModules: previousResult.graph.modules.map((m) => m.name),
-          reanalyzedModules: []
-        };
-        previousSnapshot = snapshot;
-        return { ...previousResult, written: [], stats: stats2 };
-      }
-      const activeCache = options.cache ?? cache;
       if (!activeCache.dependencyGraph && previousResult) {
         activeCache.dependencyGraph = new ModuleDependencyGraph(previousResult.graph.modules);
       }
-      const result = await compileProject({ ...options, cache: activeCache });
+      const result = await compileProject({
+        ...options,
+        cache: activeCache,
+        changedPaths: changedFiles
+      });
       const affectedModules = previousResult ? findAffectedModules(previousResult.graph.modules, result.graph.modules, changedFiles) : result.graph.modules.map((module) => module.name);
       const reusedModules = result.graph.cacheStats?.reusedModules ?? [];
       const reanalyzedModules = result.graph.cacheStats?.reanalyzedModules ?? affectedModules;
@@ -3367,14 +4709,18 @@ function createIncrementalCompiler() {
       };
       previousSnapshot = snapshot;
       previousResult = result;
+      previousCache = activeCache;
       return { ...result, stats };
     },
     reset() {
       previousSnapshot = undefined;
       previousResult = undefined;
+      previousCache = undefined;
       cache.modules.clear();
       cache.fileHashes.clear();
+      cache.generatedHashes?.clear();
       cache.dependencyGraph = undefined;
+      cache.programSession?.reset();
     },
     getCache() {
       return cache;
@@ -3382,18 +4728,21 @@ function createIncrementalCompiler() {
   };
 }
 async function updateSnapshot(previous, options, changedPaths) {
-  const rootDir = resolve(options.rootDir);
-  const outDir = resolve(options.outDir);
+  const rootDir = resolve3(options.rootDir);
+  const outDir = resolve3(options.outDir);
   const files = { ...previous.files };
   for (const changedPath of changedPaths) {
-    const absolutePath = resolve(rootDir, changedPath);
+    const absolutePath = isAbsolute(changedPath) ? resolve3(changedPath) : resolve3(rootDir, changedPath);
+    const relativeChangedPath = relative3(rootDir, absolutePath);
+    if (relativeChangedPath === ".." || relativeChangedPath.startsWith(`..${sep3}`))
+      continue;
     if (absolutePath === outDir || absolutePath.startsWith(`${outDir}/`))
       continue;
-    const relativePath = relative2(rootDir, absolutePath).split(sep2).join("/");
+    const relativePath = relative3(rootDir, absolutePath).split(sep3).join("/");
     try {
-      await access(absolutePath);
+      await access2(absolutePath);
       const content = await readFile(absolutePath);
-      files[relativePath] = createHash2("sha256").update(content).digest("hex");
+      files[relativePath] = createHash5("sha256").update(content).digest("hex");
     } catch {
       delete files[relativePath];
     }
@@ -3401,20 +4750,23 @@ async function updateSnapshot(previous, options, changedPaths) {
   return { files, optionsKey: optionsKeyOf(options) };
 }
 async function createSnapshot(options) {
-  const rootDir = resolve(options.rootDir);
-  const outDir = resolve(options.outDir);
+  const rootDir = resolve3(options.rootDir);
+  const outDir = resolve3(options.outDir);
   const paths = await listSourceFiles(rootDir, outDir);
   const files = {};
   for (const path of paths) {
     const content = await readFile(path);
-    files[relative2(rootDir, path).split(sep2).join("/")] = createHash2("sha256").update(content).digest("hex");
+    files[relative3(rootDir, path).split(sep3).join("/")] = createHash5("sha256").update(content).digest("hex");
   }
   return { files, optionsKey: optionsKeyOf(options) };
 }
 function optionsKeyOf(options) {
   return JSON.stringify({
+    rootDir: resolve3(options.rootDir),
+    outDir: resolve3(options.outDir),
     include: options.include,
     strict: options.strict,
+    writeOnError: options.writeOnError,
     moduleBoundaryPreset: options.moduleBoundaryPreset,
     moduleBoundaries: options.moduleBoundaries,
     allowRouteCommandBindings: options.allowRouteCommandBindings,
@@ -3422,27 +4774,16 @@ function optionsKeyOf(options) {
     disallowControllerDirectDb: options.disallowControllerDirectDb,
     detectOrphanModules: options.detectOrphanModules,
     generateClient: options.generateClient,
-    generatePermissions: options.generatePermissions
+    generatePermissions: options.generatePermissions,
+    typeSafety: options.typeSafety,
+    treeShakeUnusedProviders: options.treeShakeUnusedProviders
   });
 }
-async function requiresGraphRebuild(rootDir, changedFiles) {
-  for (const relativePath of changedFiles) {
-    const path = resolve(rootDir, relativePath);
-    try {
-      const source = await readFile(path, "utf8");
-      if (/@(?:Module|Injectable|Inject|Controller|Command|Query)\b|new\s+InjectionToken\b|\bdefineModule\s*\(/.test(source))
-        return true;
-    } catch {
-      return true;
-    }
-  }
-  return false;
-}
 async function listSourceFiles(rootDir, outDir) {
   const result = [];
   const visit = async (directory) => {
     for (const entry of await readdir(directory, { withFileTypes: true })) {
-      const path = resolve(directory, entry.name);
+      const path = resolve3(directory, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === ".git" || path === outDir)
           continue;
@@ -3500,7 +4841,9 @@ class ModuleDependencyGraph {
         if (!this.dependents.has(imp)) {
           this.dependents.set(imp, new Set);
         }
-        this.dependents.get(imp).add(modName);
+        const dependents = this.dependents.get(imp);
+        if (dependents)
+          dependents.add(modName);
       }
     }
   }
@@ -3511,7 +4854,9 @@ class ModuleDependencyGraph {
     if (!this.fileOwners.has(normalized)) {
       this.fileOwners.set(normalized, new Set);
     }
-    this.fileOwners.get(normalized).add(moduleName);
+    const owners = this.fileOwners.get(normalized);
+    if (owners)
+      owners.add(moduleName);
   }
   getModulesOwningFile(filePath) {
     const normalized = filePath.replace(/\.(tsx?|mts|cts)$/, "");
@@ -3527,12 +4872,14 @@ class ModuleDependencyGraph {
       }
     }
     if (directlyAffected.size === 0) {
-      return Array.from(this.moduleMap.keys());
+      return [];
     }
     const affected = new Set(directlyAffected);
     const queue = Array.from(directlyAffected);
     while (queue.length > 0) {
       const current = queue.shift();
+      if (!current)
+        continue;
       const dependents = this.dependents.get(current);
       if (dependents) {
         for (const dep of dependents) {
@@ -3560,8 +4907,8 @@ function findAffectedModules(previous, current, changedFiles) {
 // src/watch.ts
 var DEFAULT_DEBOUNCE_MS = 100;
 function watchProject(options) {
-  const rootDir = resolve2(options.rootDir);
-  const outDir = resolve2(options.outDir);
+  const rootDir = resolve4(options.rootDir);
+  const outDir = resolve4(options.outDir);
   const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
   let timer;
   let closed = false;
@@ -3571,8 +4918,12 @@ function watchProject(options) {
   let watcher;
   const incremental = createIncrementalCompiler();
   let initialEvent;
-  let resolveReady;
-  let rejectReady;
+  let resolveReady = () => {
+    return;
+  };
+  let rejectReady = () => {
+    return;
+  };
   const ready = new Promise((resolvePromise, rejectPromise) => {
     resolveReady = resolvePromise;
     rejectReady = rejectPromise;
@@ -3641,12 +4992,12 @@ function watchProject(options) {
     watcher = watch(rootDir, { recursive: true }, (_eventType, filename) => {
       if (!filename)
         return schedule();
-      const changedPath = resolve2(rootDir, filename.toString());
-      const relativePath = relative3(outDir, changedPath);
+      const changedPath = resolve4(rootDir, filename.toString());
+      const relativePath = relative4(outDir, changedPath);
       if (!relativePath.startsWith("..") && relativePath !== "")
         return;
       if (/\.(tsx?|mts|cts)$/.test(changedPath))
-        schedule(relative3(rootDir, changedPath));
+        schedule(relative4(rootDir, changedPath));
     });
     if (initialEvent)
       resolveReady(initialEvent);
@@ -3668,6 +5019,9 @@ function watchProject(options) {
 }
 
 // src/cli.ts
+function isModuleBoundaryPresetName(value) {
+  return value === "modular-monolith" || value === "feature-slices" || value === "vertical-slices" || value === "angular-enterprise" || value === "angular" || value === "clean-architecture" || value === "domain-driven";
+}
 function printUsage() {
   console.log(`
 @supacloud/compiler CLI
@@ -3691,7 +5045,7 @@ Commands:
 Options:
   --root, -r <dir>    Application source root (default: current directory or first positional argument)
   --out, -o <dir>     Artifact output directory (default: <rootDir>/generated)
-  --strict            Treat all warnings as errors
+  --strict            Enable type-safety gates and treat all warnings as errors
   --client            Generate typed API client in client.ts
   --permissions       Generate typed permissions registry in permissions.ts
   --debounce <ms>     Debounce source changes in dev mode (default: 100)
@@ -3742,7 +5096,12 @@ async function run() {
     } else if (arg === "--json") {
       json = true;
     } else if (arg === "--preset" || arg === "-p") {
-      preset = args[++i];
+      const presetArg = args[++i];
+      if (!isModuleBoundaryPresetName(presetArg)) {
+        console.error(`Error: --preset requires a known preset, received "${presetArg ?? ""}"`);
+        process.exit(1);
+      }
+      preset = presetArg;
     } else if (!arg.startsWith("-") && rootDir === ".") {
       if (command === "explain" && !query)
         query = arg;
@@ -3752,8 +5111,8 @@ async function run() {
       query = arg;
     }
   }
-  const resolvedRoot = resolve3(process.cwd(), rootDir);
-  const resolvedOut = outDir ? resolve3(process.cwd(), outDir) : resolve3(resolvedRoot, "generated");
+  const resolvedRoot = resolve5(process.cwd(), rootDir);
+  const resolvedOut = outDir ? resolve5(process.cwd(), outDir) : resolve5(resolvedRoot, "generated");
   if (command === "compile") {
     const result = await compileProject({
       rootDir: resolvedRoot,