@cloudcare/hvigor-ohos-plugin 0.1.1 → 0.1.2-alpha.1

package/hvigorCompile/ft-cold-launch-transform.ts

@@ -5,21 +5,45 @@
  * the compiler's in-memory source. Application files are never modified.
  */
 
-declare const require: {
-  main: {
-    require(moduleName: string): any;
-  };
-};
+import { hasRuntimeDependency } from './ft-transform-context';
+import { createLexicalResolver } from './ft-lexical-scope';
+import { allocateName as selectIdentifierName, collectIdentifierNames } from './ft-generated-names';
+
+declare const require: any;
 declare const __dirname: string;
 
 type TypeScriptApi = any;
-type AbilityClassKind = 'stage' | 'ui' | 'other';
+type AbilityClassKind = 'stage' | 'ui' | 'other' | 'intent' | 'legacyIntent';
+type SourceReader = (fileName: string) => string | undefined;
+
+interface AbilityClassInfo {
+  kind: AbilityClassKind | null;
+  applicationBase: boolean;
+  base?: any;
+}
+
+interface AbilityBase {
+  kind: AbilityClassKind | null;
+  declaration?: any;
+}
+
+interface LaunchParameterTypes {
+  want: string;
+  abilityConstant: string;
+  needed: boolean;
+}
 
 interface ColdLaunchInjection {
   position: number;
+  end?: number;
   content: string;
 }
 
+interface ColdLaunchInjections {
+  injections: ColdLaunchInjection[];
+  hasUIAbility: boolean;
+}
+
 const COLD_LAUNCH_BRIDGE_IMPORT = '@guancecloud/ft_sdk/Index';
 const COLD_LAUNCH_TRANSFORM_MARKER = '/* guance-cold-launch-transform:instrumented */';
 
@@ -35,27 +59,6 @@ function visit(ts: TypeScriptApi, node: any, visitor: (current: any) => void): v
   ts.forEachChild(node, (child: any) => visit(ts, child, visitor));
 }
 
-function collectIdentifierNames(ts: TypeScriptApi, sourceFile: any): Set<string> {
-  const identifiers = new Set<string>();
-  visit(ts, sourceFile, (node: any) => {
-    if (ts.isIdentifier(node)) {
-      identifiers.add(node.text);
-    }
-  });
-  return identifiers;
-}
-
-function selectBridgeName(identifiers: Set<string>): string {
-  const baseName = '__ftColdLaunchBridge';
-  let bridgeName = baseName;
-  let suffix = 1;
-  while (identifiers.has(bridgeName)) {
-    bridgeName = `${baseName}${suffix}`;
-    suffix++;
-  }
-  return bridgeName;
-}
-
 function getPluginVersion(): string {
   try {
     const fileSystem = require.main.require('fs');
@@ -82,7 +85,57 @@ function findImportInsertionOffset(ts: TypeScriptApi, sourceFile: any): number {
   return offset;
 }
 
+/** Only opt in when a readable HAP manifest explicitly has no module entry. */
+function needsUIAbilityModuleFallback(ts: TypeScriptApi, id: string, readSource?: SourceReader): boolean {
+  const normalized = id.replace(/\\/g, '/');
+  const sourceIndex = normalized.lastIndexOf('/src/main/ets/');
+  if (sourceIndex < 0) {
+    return false;
+  }
+  const manifestPath = normalized.slice(0, sourceIndex) + '/src/main/module.json5';
+  try {
+    const nodeRequire = require.main && typeof require.main.require === 'function'
+      ? require.main.require.bind(require.main) : require;
+    const code = readSource ? readSource(manifestPath) : nodeRequire('fs').readFileSync(manifestPath, 'utf8');
+    if (typeof code !== 'string') {
+      return false;
+    }
+    // Parsing an object initializer accepts JSON5 comments, single quotes and
+    // unquoted keys without mistaking nested ability srcEntry fields for Stage.
+    const parsed = ts.createSourceFile(manifestPath, `const __manifest = ${code}`,
+      ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    if (parsed.parseDiagnostics.length > 0 || parsed.statements.length !== 1 ||
+      !ts.isVariableStatement(parsed.statements[0])) {
+      return false;
+    }
+    const root = parsed.statements[0].declarationList.declarations[0].initializer;
+    const property = (object: any, name: string): any | undefined => {
+      if (!object || !ts.isObjectLiteralExpression(object)) {
+        return undefined;
+      }
+      const matches = object.properties.filter((item: any) => ts.isPropertyAssignment(item) &&
+        (ts.isIdentifier(item.name) || ts.isStringLiteral(item.name)) && item.name.text === name);
+      return matches.length > 0 ? matches[matches.length - 1].initializer : undefined;
+    };
+    const module = property(root, 'module');
+    const type = property(module, 'type');
+    if (!type || !ts.isStringLiteral(type) || (type.text !== 'entry' && type.text !== 'feature')) {
+      return false;
+    }
+    const stageEntry = property(module, 'srcEntry');
+    return stageEntry === undefined || (ts.isStringLiteral(stageEntry) && stageEntry.text.trim().length === 0);
+  } catch (_) {
+    return false;
+  }
+}
+
 function classifyAbilityBaseName(name: string): AbilityClassKind | null {
+  if (name === 'InsightIntentEntryExecutor') {
+    return 'intent';
+  }
+  if (name === 'InsightIntentExecutor') {
+    return 'legacyIntent';
+  }
   if (name === 'AbilityStage') {
     return 'stage';
   }
@@ -95,54 +148,218 @@ function classifyAbilityBaseName(name: string): AbilityClassKind | null {
   return null;
 }
 
-function collectAbilityBindings(ts: TypeScriptApi, sourceFile: any): Map<string, AbilityClassKind> {
-  const bindings = new Map<string, AbilityClassKind>();
-  sourceFile.statements.forEach((statement: any) => {
-    if (!ts.isImportDeclaration(statement) || !statement.moduleSpecifier ||
-      !ts.isStringLiteral(statement.moduleSpecifier) || !statement.importClause) {
-      return;
-    }
-    const moduleName = statement.moduleSpecifier.text;
-    if (!moduleName.startsWith('@ohos.app.ability/') && moduleName !== '@kit.AbilityKit') {
-      return;
+function bindingContains(ts: TypeScriptApi, binding: any, name: string): boolean {
+  if (ts.isIdentifier(binding)) {
+    return binding.text === name;
+  }
+  return !!binding.elements && binding.elements.some((element: any) =>
+    ts.isBindingElement(element) && bindingContains(ts, element.name, name));
+}
+
+function findValueDeclaration(ts: TypeScriptApi, location: any, name: string): any | null {
+  for (let scope = location.parent; scope; scope = scope.parent) {
+    if (ts.isClassDeclaration(scope) && scope.name && scope.name.text === name) {
+      return scope;
     }
-    const importClause = statement.importClause;
-    if (importClause.name) {
-      const defaultKind = classifyAbilityBaseName(moduleName.substring(moduleName.lastIndexOf('.') + 1));
-      if (defaultKind) {
-        bindings.set(importClause.name.text, defaultKind);
+    if (ts.isFunctionLike(scope)) {
+      const parameter = scope.parameters.find((item: any) => bindingContains(ts, item.name, name));
+      if (parameter) {
+        return parameter;
       }
     }
-    if (!importClause.namedBindings || !ts.isNamedImports(importClause.namedBindings)) {
-      return;
-    }
-    importClause.namedBindings.elements.forEach((element: any) => {
-      const importedName = element.propertyName ? element.propertyName.text : element.name.text;
-      const kind = classifyAbilityBaseName(importedName);
-      if (kind) {
-        bindings.set(element.name.text, kind);
+    for (const statement of scope.statements || []) {
+      if (ts.isImportDeclaration(statement) && statement.importClause) {
+        const clause = statement.importClause;
+        if (clause.name && clause.name.text === name) {
+          return clause;
+        }
+        if (clause.namedBindings) {
+          if (ts.isNamespaceImport(clause.namedBindings) && clause.namedBindings.name.text === name) {
+            return clause.namedBindings;
+          }
+          if (ts.isNamedImports(clause.namedBindings)) {
+            const imported = clause.namedBindings.elements.find((item: any) => item.name.text === name);
+            if (imported) {
+              return imported;
+            }
+          }
+        }
       }
-    });
-  });
-  return bindings;
+      if ((ts.isClassDeclaration(statement) || ts.isFunctionDeclaration(statement) ||
+        ts.isEnumDeclaration(statement) || ts.isModuleDeclaration(statement)) &&
+        statement.name && statement.name.text === name) {
+        return statement;
+      }
+      if (ts.isVariableStatement(statement)) {
+        const variable = statement.declarationList.declarations.find((item: any) =>
+          bindingContains(ts, item.name, name));
+        if (variable) {
+          return variable;
+        }
+      }
+    }
+  }
+  return null;
 }
 
-function classAbilityKind(ts: TypeScriptApi, classDeclaration: any,
-  abilityBindings: Map<string, AbilityClassKind>): AbilityClassKind | null {
-  if (!classDeclaration.heritageClauses) {
+/** Resolve source-visible inheritance without reading through our own transform hook. */
+function createAbilityClassResolver(ts: TypeScriptApi, sourceFile: any, readSource?: SourceReader):
+  (declaration: any) => AbilityClassInfo {
+  const nodeRequire = require.main && typeof require.main.require === 'function'
+    ? require.main.require.bind(require.main) : require;
+  const path = nodeRequire('path');
+  const sources = new Map<string, any | null>();
+  sources.set(path.resolve(sourceFile.fileName), sourceFile);
+  const classCache = new Map<any, AbilityClassInfo>();
+  const resolvingClasses = new Set<any>();
+  const resolvingExports = new Set<string>();
+  const unknown: AbilityBase = { kind: null };
+
+  const loadRelativeSource = (from: any, moduleName: string): any | null => {
+    if (!moduleName.startsWith('.')) {
+      return null;
+    }
+    const base = path.resolve(path.dirname(from.fileName), moduleName);
+    const candidates = /\.(ets|ts)$/.test(base) ? [base] :
+      [base + '.ets', base + '.ts', path.join(base, 'Index.ets'), path.join(base, 'index.ets'),
+        path.join(base, 'Index.ts'), path.join(base, 'index.ts')];
+    for (const fileName of candidates) {
+      if (!isApplicationArkTsSource(fileName)) {
+        continue;
+      }
+      if (!sources.has(fileName)) {
+        let parsed: any | null = null;
+        try {
+          const code = readSource ? readSource(fileName) : nodeRequire('fs').readFileSync(fileName, 'utf8');
+          if (typeof code === 'string') {
+            parsed = ts.createSourceFile(fileName, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+          }
+        } catch (_) {
+          // A missing or unresolved source is not evidence of an Ability base.
+        }
+        sources.set(fileName, parsed);
+      }
+      if (sources.get(fileName)) {
+        return sources.get(fileName);
+      }
+    }
     return null;
-  }
-  for (const clause of classDeclaration.heritageClauses) {
-    if (clause.token !== ts.SyntaxKind.ExtendsKeyword || clause.types.length === 0) {
-      continue;
+  };
+
+  const resolveModule = (from: any, moduleName: string, exportedName: string): AbilityBase => {
+    const name = exportedName === 'default' ? moduleName.slice(moduleName.lastIndexOf('.') + 1) : exportedName;
+    const kind = classifyAbilityBaseName(name);
+    if (moduleName === '@kit.AbilityKit' || moduleName.startsWith('@ohos.app.ability.') ||
+      (kind === 'other' && (moduleName.startsWith('@kit.') || moduleName.startsWith('@ohos.')))) {
+      return { kind };
     }
-    const expression = clause.types[0].expression;
-    if (!ts.isIdentifier(expression)) {
-      continue;
+    const imported = loadRelativeSource(from, moduleName);
+    return imported ? resolveExport(imported, exportedName) : unknown;
+  };
+
+  const resolveBinding = (declaration: any, member?: string): AbilityBase => {
+    if (!declaration) {
+      return unknown;
     }
-    return abilityBindings.get(expression.text) || classifyAbilityBaseName(expression.text);
-  }
-  return null;
+    if (ts.isClassDeclaration(declaration)) {
+      return { kind: resolveClass(declaration).kind, declaration };
+    }
+    let importDeclaration = declaration;
+    while (importDeclaration && !ts.isImportDeclaration(importDeclaration)) {
+      importDeclaration = importDeclaration.parent;
+    }
+    if (!importDeclaration || importDeclaration.importClause.isTypeOnly || declaration.isTypeOnly) {
+      return unknown;
+    }
+    let exportedName: string;
+    if (ts.isImportClause(declaration)) {
+      exportedName = 'default';
+    } else if (ts.isImportSpecifier(declaration)) {
+      exportedName = (declaration.propertyName || declaration.name).text;
+    } else if (ts.isNamespaceImport(declaration) && member) {
+      exportedName = member;
+    } else {
+      return unknown;
+    }
+    return resolveModule(importDeclaration.getSourceFile(), importDeclaration.moduleSpecifier.text, exportedName);
+  };
+
+  const resolveExpression = (expression: any): AbilityBase => {
+    if (ts.isIdentifier(expression)) {
+      return resolveBinding(findValueDeclaration(ts, expression, expression.text));
+    }
+    if (ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.expression)) {
+      return resolveBinding(findValueDeclaration(ts, expression, expression.expression.text), expression.name.text);
+    }
+    return unknown;
+  };
+
+  const resolveExport = (source: any, name: string): AbilityBase => {
+    const key = `${source.fileName}:${name}`;
+    if (resolvingExports.has(key)) {
+      return unknown;
+    }
+    resolvingExports.add(key);
+    try {
+      for (const statement of source.statements) {
+        if (ts.isClassDeclaration(statement)) {
+          const modifiers = statement.modifiers || [];
+          const isDefault = modifiers.some((item: any) => item.kind === ts.SyntaxKind.DefaultKeyword);
+          const isExported = modifiers.some((item: any) => item.kind === ts.SyntaxKind.ExportKeyword);
+          if ((name === 'default' && isDefault) ||
+            (name !== 'default' && isExported && statement.name && statement.name.text === name)) {
+            return resolveBinding(statement);
+          }
+        }
+        if (name === 'default' && ts.isExportAssignment(statement) && !statement.isExportEquals) {
+          return resolveExpression(statement.expression);
+        }
+        if (!ts.isExportDeclaration(statement) || statement.isTypeOnly) {
+          continue;
+        }
+        if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+          const exported = statement.exportClause.elements.find((item: any) => item.name.text === name);
+          if (exported && !exported.isTypeOnly) {
+            const localName = (exported.propertyName || exported.name).text;
+            return statement.moduleSpecifier
+              ? resolveModule(source, statement.moduleSpecifier.text, localName)
+              : resolveBinding(findValueDeclaration(ts, statement, localName));
+          }
+        } else if (!statement.exportClause && statement.moduleSpecifier && name !== 'default') {
+          const resolved = resolveModule(source, statement.moduleSpecifier.text, name);
+          if (resolved.kind) {
+            return resolved;
+          }
+        }
+      }
+      return unknown;
+    } finally {
+      resolvingExports.delete(key);
+    }
+  };
+
+  const resolveClass = (declaration: any): AbilityClassInfo => {
+    const cached = classCache.get(declaration);
+    if (cached) {
+      return cached;
+    }
+    if (resolvingClasses.has(declaration)) {
+      return { kind: null, applicationBase: false };
+    }
+    resolvingClasses.add(declaration);
+    let base: AbilityBase = unknown;
+    for (const clause of declaration.heritageClauses || []) {
+      if (clause.token === ts.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
+        base = resolveExpression(clause.types[0].expression);
+        break;
+      }
+    }
+    const info: AbilityClassInfo = { kind: base.kind, applicationBase: !!base.declaration, base: base.declaration };
+    resolvingClasses.delete(declaration);
+    classCache.set(declaration, info);
+    return info;
+  };
+  return resolveClass;
 }
 
 function methodIndentation(code: string, method: any): string {
@@ -166,6 +383,50 @@ function blockIndentation(code: string, block: any): string {
   return (match ? match[0] : '') + '  ';
 }
 
+function intentDecoratorString(ts: TypeScriptApi, declaration: any, field: string): string {
+  const decorators = ts.canHaveDecorators && ts.canHaveDecorators(declaration)
+    ? (ts.getDecorators(declaration) || []) : (declaration.decorators || []);
+  for (const decorator of decorators) {
+    const call = decorator.expression;
+    if (!ts.isCallExpression(call) || call.arguments.length === 0 ||
+      !ts.isObjectLiteralExpression(call.arguments[0])) {
+      continue;
+    }
+    for (const property of call.arguments[0].properties) {
+      if (ts.isPropertyAssignment(property) && property.name && property.name.text === field &&
+        ts.isStringLiteral(property.initializer)) {
+        return JSON.stringify(property.initializer.text);
+      }
+    }
+  }
+  return "''";
+}
+
+function callableMember(ts: TypeScriptApi, member: any): any | undefined {
+  if (ts.isMethodDeclaration(member) && member.body) return member;
+  if (ts.isPropertyDeclaration(member) && member.initializer &&
+    (ts.isArrowFunction(member.initializer) || ts.isFunctionExpression(member.initializer))) return member.initializer;
+  return undefined;
+}
+
+function memberName(ts: TypeScriptApi, member: any): string | undefined {
+  return member.name && (ts.isIdentifier(member.name) || ts.isStringLiteral(member.name)) ? member.name.text : undefined;
+}
+
+/** Insert into the actual parameter list, ignoring parentheses in return types/comments. */
+function addLaunchParameters(ts: TypeScriptApi, sourceFile: any, callable: any,
+  added: string[], injections: ColdLaunchInjection[]): void {
+  const close = callable.getChildren(sourceFile).find((child: any) => child.kind === ts.SyntaxKind.CloseParenToken);
+  if (close) {
+    const separator = callable.parameters.length > 0 && !callable.parameters.hasTrailingComma ? ', ' : '';
+    injections.push({ position: close.getStart(sourceFile), content: separator + added.join(', ') });
+  } else {
+    // A single unparenthesized arrow parameter must become a parameter list.
+    injections.push({ position: callable.parameters[0].getStart(sourceFile), content: '(' });
+    injections.push({ position: callable.parameters.end, content: ', ' + added.join(', ') + ')' });
+  }
+}
+
 function collectWindowStageParameterNames(ts: TypeScriptApi, sourceFile: any, method: any): Set<string> {
   const names = new Set<string>();
   method.parameters.forEach((parameter: any) => {
@@ -181,65 +442,221 @@ function collectWindowStageParameterNames(ts: TypeScriptApi, sourceFile: any, me
 }
 
 function createFirstFrameRetryInjections(ts: TypeScriptApi, sourceFile: any, code: string,
-  method: any, bridgeName: string, windowStageNames: Set<string>): ColdLaunchInjection[] {
-  const injections: ColdLaunchInjection[] = [];
+  method: any, bridgeName: string, windowStageNames: Set<string>, identifiers: Set<string>,
+  resolve: (location: any, name: string) => any | undefined): ColdLaunchInjection[] {
+  const candidates: any[] = [];
   visit(ts, method.body, (node: any) => {
-    if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression)) {
-      return;
-    }
+    if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression) ||
+      (ts.isOptionalChain && ts.isOptionalChain(node))) return;
     const delegate = node.expression.expression;
     if (!ts.isIdentifier(delegate) || !windowStageNames.has(delegate.text) ||
-      node.expression.name.text !== 'loadContent' || node.arguments.length === 0) {
-      return;
-    }
-    const windowStageName = delegate.text;
+      node.expression.name.text !== 'loadContent' || node.arguments.length < 2 || node.arguments.length > 3) return;
+    const parameter = resolve(delegate, delegate.text);
+    if (!parameter || !method.parameters.includes(parameter)) return;
     const callback = node.arguments[node.arguments.length - 1];
-    if ((!ts.isArrowFunction(callback) && !ts.isFunctionExpression(callback)) || !ts.isBlock(callback.body)) {
-      return;
+    if ((!ts.isArrowFunction(callback) && !ts.isFunctionExpression(callback)) || !ts.isBlock(callback.body)) return;
+    candidates.push({ node, callback, parameter,
+      stage: selectIdentifierName(identifiers, '__ftWindowStage'),
+      arguments: node.arguments.slice(0, -1).map((_arg: any, index: number) =>
+        selectIdentifierName(identifiers, index === 0 ? '__ftContentUrl' : '__ftContentStorage')) });
+  });
+  const start = (candidate: any): number => candidate.node.getStart(sourceFile);
+  const contains = (outer: any, inner: any): boolean => outer !== inner &&
+    start(outer) <= start(inner) && outer.node.end >= inner.node.end;
+  const render = (from: number, to: number): string => {
+    const included = candidates.filter(item => start(item) >= from && item.node.end <= to);
+    const direct = included.filter(item => !included.some(outer => contains(outer, item)))
+      .sort((left, right) => start(right) - start(left));
+    let output = code.slice(from, to);
+    for (const candidate of direct) {
+      const rendered = renderCandidate(candidate);
+      output = output.slice(0, start(candidate) - from) + rendered + output.slice(candidate.node.end - from);
     }
+    return output;
+  };
+  const renderCandidate = (candidate: any): string => {
+    const { node, callback, parameter, stage } = candidate;
+    const bodyStart = callback.body.getStart(sourceFile) + 1;
     const indentation = blockIndentation(code, callback.body);
-    const errorParameter = callback.parameters.length > 0 && ts.isIdentifier(callback.parameters[0].name)
+    const error = callback.parameters.length > 0 && ts.isIdentifier(callback.parameters[0].name)
       ? callback.parameters[0].name.text : null;
-    const retry = `${bridgeName}.observeFirstFrame(${windowStageName});`;
-    const content = errorParameter === null
-      ? `\n${indentation}${retry}`
-      : `\n${indentation}if (!${errorParameter} || !${errorParameter}.code) {\n` +
-        `${indentation}  ${retry}\n${indentation}}`;
-    injections.push({ position: callback.body.getStart(sourceFile) + 1, content });
-  });
-  return injections;
+    const retry = `${bridgeName}.observeFirstFrame(${stage});`;
+    const hook = error === null ? `\n${indentation}${retry}` :
+      `\n${indentation}if (!${error} || !${error}.code) {\n${indentation}  ${retry}\n${indentation}}`;
+    const callbackCode = code.slice(callback.getStart(sourceFile), bodyStart) + hook + render(bodyStart, callback.end);
+    const argumentNames: string[] = candidate.arguments;
+    const parameterType = parameter.type ? parameter.type.getText(sourceFile) : 'Object';
+    const declarations = [`${stage}: ${parameterType}`, ...argumentNames.map((name: string, index: number) =>
+      `${name}: ${index === 0 ? 'string' : 'LocalStorage'}`)];
+    // Evaluate the receiver and non-callback arguments at the original call site.
+    // Each execution captures a separate stage; callbacks cannot shadow or overwrite it.
+    const values = [node.expression.expression.getText(sourceFile), ...node.arguments.slice(0, -1)
+      .map((argument: any) => render(argument.getStart(sourceFile), argument.end))];
+    const statement = node.parent;
+    const separator = ts.isExpressionStatement(statement) && (ts.isBlock(statement.parent) ||
+      ts.isSourceFile(statement.parent) || ts.isCaseClause(statement.parent) || ts.isDefaultClause(statement.parent)) ? ';' : '';
+    return `${separator}((${declarations.join(', ')}) => ${stage}.loadContent(${argumentNames.join(', ')}, ` +
+      `${callbackCode}))(${values.join(', ')})`;
+  };
+  return candidates.filter(item => !candidates.some(outer => contains(outer, item)))
+    .map(item => ({ position: start(item), end: item.node.end, content: renderCandidate(item) }));
 }
 
 function createColdLaunchInjections(ts: TypeScriptApi, sourceFile: any, code: string,
-  bridgeName: string, pluginVersion: string): ColdLaunchInjection[] {
+  bridgeName: string, pluginVersion: string, identifiers: Set<string>,
+  launchTypes: LaunchParameterTypes, readSource?: SourceReader): ColdLaunchInjections {
   const injections: ColdLaunchInjection[] = [];
-  const abilityBindings = collectAbilityBindings(ts, sourceFile);
+  let hasUIAbility = false;
+  const resolve = createLexicalResolver(ts, sourceFile);
+  const resolveClass = createAbilityClassResolver(ts, sourceFile, readSource);
   const pluginVersionArgument = pluginVersion.length > 0 ? `, ${JSON.stringify(pluginVersion)}` : '';
+  const availability = new Map<string, boolean>();
+  const inheritedState = (declaration: any, method: string): { covered: boolean; member?: any } => {
+    const seen = new Set<any>();
+    for (let base = resolveClass(declaration).base; base && !seen.has(base); base = resolveClass(base).base) {
+      seen.add(base);
+      const id = base.getSourceFile().fileName;
+      if (!availability.has(id)) availability.set(id, hasRuntimeDependency(ts, id, '@guancecloud/ft_sdk', readSource));
+      // An instrumented intermediate class either owns the hook or supplies a forwarding hook.
+      if (availability.get(id)) return { covered: true };
+      const member = base.members.find((item: any) => memberName(ts, item) === method &&
+        !(item.modifiers || []).some((modifier: any) => modifier.kind === ts.SyntaxKind.StaticKeyword));
+      if (member) return { covered: false, member };
+    }
+    return { covered: false };
+  };
+  const wrapInherited = (declaration: any, name: string, hook: string, launch: boolean, inherited: any): void => {
+    const original = selectIdentifierName(identifiers, '__ftInheritedCall');
+    const want = selectIdentifierName(identifiers, '__ftInheritedWant');
+    const param = selectIdentifierName(identifiers, '__ftInheritedLaunch');
+    if (launch) launchTypes.needed = true;
+    const baseType = declaration.heritageClauses.find((item: any) => item.token === ts.SyntaxKind.ExtendsKeyword)
+      .types[0].getText(sourceFile);
+    const callable = callableMember(ts, inherited);
+    const signature = callable || (inherited.type && ts.isFunctionTypeNode(inherited.type) ? inherited.type : undefined);
+    const count = signature && !signature.parameters.some((parameter: any) => parameter.dotDotDotToken)
+      ? signature.parameters.length : 2;
+    const parameters = launch ? `${want}?: ${launchTypes.want}, ${param}?: ${launchTypes.abilityConstant}.LaunchParam` : '';
+    const passed = launch ? [`${want} as ${launchTypes.want}`, `${param} as ${launchTypes.abilityConstant}.LaunchParam`]
+      .slice(0, count).join(', ') : '';
+    const hookText = hook.replace(/\$want/g, want).replace(/\$launch/g, param);
+    // Store the original callable on the same instance. Calling this slot keeps
+    // its receiver and concrete return type, including inherited function fields,
+    // without bind's dynamic return type or unsupported generic inference.
+    injections.push({ position: declaration.end - 1,
+      content: `\n  private ${original} = (this as Object as ${baseType}).${name};\n` +
+        `  ${name} = (${parameters}) => { ${hookText} return this.${original}(${passed}); };\n` });
+  };
+
   visit(ts, sourceFile, (node: any) => {
     if (!ts.isClassDeclaration(node)) {
       return;
     }
-    const kind = classAbilityKind(ts, node, abilityBindings);
+    const classification = resolveClass(node);
+    const kind = classification.kind;
     if (!kind) {
       return;
     }
+    if (kind === 'ui') {
+      hasUIAbility = true;
+    }
     let hasOnCreate = false;
-    node.members.forEach((member: any) => {
-      if (!ts.isMethodDeclaration(member) || !member.body || !member.name || !ts.isIdentifier(member.name)) {
+    let hasOnForeground = false;
+    let hasOnBackground = false;
+    let hasOnNewWant = false;
+    node.members.forEach((declaration: any) => {
+      if ((declaration.modifiers || []).some((modifier: any) => modifier.kind === ts.SyntaxKind.StaticKeyword)) return;
+      const name = memberName(ts, declaration);
+      if (name === 'onCreate') hasOnCreate = true;
+      if (name === 'onForeground') hasOnForeground = true;
+      if (name === 'onBackground') hasOnBackground = true;
+      if (name === 'onNewWant') hasOnNewWant = true;
+      const member = callableMember(ts, declaration);
+      if (!member || !name) return;
+      const indentation = methodIndentation(code, declaration);
+      const block = ts.isBlock(member.body);
+      const position = member.body.getStart(sourceFile) + (block ? 1 : 0);
+      // Expression-bodied lifecycle properties retain their expression result.
+      if (!block) {
+        const recognized = kind === 'intent' ? name === 'onExecute' : kind === 'legacyIntent'
+          ? ['onExecuteInUIAbilityForegroundMode', 'onExecuteInUIAbilityBackgroundMode'].includes(name)
+          : name === 'onCreate' || (kind === 'ui' &&
+            (['onForeground', 'onBackground', 'onNewWant'].includes(name) ||
+            (name === 'onWindowStageCreate' && member.parameters.length > 0 && ts.isIdentifier(member.parameters[0].name))));
+        if (recognized) {
+          injections.push({ position, content: '{' });
+          injections.push({ position: member.body.end, content: '; }' });
+        }
+      }
+      const finish = (): void => {
+        if (!block) injections.push({ position, content: '\n' + indentation + 'return ' });
+      };
+      if (kind === 'intent' || kind === 'legacyIntent') {
+        let mode: string | null = null;
+        if (kind === 'intent' && name === 'onExecute') {
+          mode = 'this.executeMode';
+        } else if (kind === 'legacyIntent' && name === 'onExecuteInUIAbilityForegroundMode') {
+          mode = '0';
+        } else if (kind === 'legacyIntent' && name === 'onExecuteInUIAbilityBackgroundMode') {
+          mode = '1';
+        }
+        if (mode !== null) {
+          const intentName = kind === 'intent' ? intentDecoratorString(ts, node, 'intentName') :
+            (member.parameters.length > 0 && ts.isIdentifier(member.parameters[0].name)
+              ? member.parameters[0].name.text : "''");
+          const abilityName = kind === 'intent' ? intentDecoratorString(ts, node, 'abilityName') : "''";
+          injections.push({ position, content: `\n${indentation}${bridgeName}.recordInsightIntentExecute(` +
+            `${mode}, ${intentName}, this.context, ${abilityName});` });
+        }
+        if (mode !== null) finish();
         return;
       }
-      const indentation = methodIndentation(code, member);
-      const position = member.body.getStart(sourceFile) + 1;
-      if (member.name.text === 'onCreate') {
+      if (name === 'onCreate') {
         hasOnCreate = true;
-        let content = `\n${indentation}${bridgeName}.recordApplicationInit(this.context${pluginVersionArgument});`;
+        let content = kind === 'ui' ? '' :
+          `\n${indentation}${bridgeName}.recordApplicationInit(this.context${pluginVersionArgument});`;
         if (kind === 'ui') {
-          content += `\n${indentation}${bridgeName}.recordFirstUIAbilityCreate();`;
+          const parameters = member.parameters;
+          let wantName = parameters.length > 0 && ts.isIdentifier(parameters[0].name)
+            ? parameters[0].name.text : 'undefined';
+          let launchParamName = parameters.length > 1 && ts.isIdentifier(parameters[1].name)
+            ? parameters[1].name.text : 'undefined';
+          // Even an onCreate() that ignores both parameters must pass the
+          // actual system reason to the SDK. Add typed optional parameters
+          // to the in-memory source without changing the application's file.
+          if (parameters.length < 2) {
+            launchTypes.needed = true;
+            const added: string[] = [];
+            if (parameters.length === 0) {
+              wantName = selectIdentifierName(identifiers, '__ftLaunchWant');
+              added.push(`${wantName}?: ${launchTypes.want}`);
+            }
+            launchParamName = selectIdentifierName(identifiers, '__ftLaunchParam');
+            added.push(`${launchParamName}?: ${launchTypes.abilityConstant}.LaunchParam`);
+            addLaunchParameters(ts, sourceFile, member, added, injections);
+          }
+          content += `\n${indentation}${bridgeName}.recordFirstUIAbilityCreate(${launchParamName}, ${wantName}, this);`;
         }
         injections.push({ position, content });
+        finish();
         return;
       }
-      if (kind !== 'ui' || member.name.text !== 'onWindowStageCreate' || member.parameters.length === 0) {
+      if (kind === 'ui' && (name === 'onForeground' || name === 'onBackground' ||
+        name === 'onNewWant')) {
+        if (name === 'onForeground') {
+          hasOnForeground = true;
+        } else if (name === 'onBackground') {
+          hasOnBackground = true;
+        } else {
+          hasOnNewWant = true;
+        }
+        const hook = name === 'onForeground' ? 'recordUIAbilityForeground' :
+          (name === 'onBackground' ? 'recordUIAbilityBackground' : 'recordUIAbilityNewWant');
+        injections.push({ position, content: `\n${indentation}${bridgeName}.${hook}(this);` });
+        finish();
+        return;
+      }
+      if (kind !== 'ui' || name !== 'onWindowStageCreate' || member.parameters.length === 0) {
         return;
       }
       const windowStageParameter = member.parameters[0];
@@ -249,64 +666,125 @@ function createColdLaunchInjections(ts: TypeScriptApi, sourceFile: any, code: st
       const windowStageName = windowStageParameter.name.text;
       injections.push({
         position,
-        content: `\n${indentation}${bridgeName}.observeFirstFrame(${windowStageName});`
+        content: `\n${indentation}if (${windowStageName}) { ${bridgeName}.observeFirstFrame(${windowStageName}); }`
       });
+      finish();
     });
     if (kind === 'ui') {
-      node.members.forEach((member: any) => {
-        if (!ts.isMethodDeclaration(member) || !member.body) {
-          return;
-        }
+      node.members.forEach((declaration: any) => {
+        if ((declaration.modifiers || []).some((modifier: any) => modifier.kind === ts.SyntaxKind.StaticKeyword)) return;
+        const member = callableMember(ts, declaration);
+        if (!member) return;
         const windowStageNames = collectWindowStageParameterNames(ts, sourceFile, member);
         if (windowStageNames.size > 0) {
           injections.push(...createFirstFrameRetryInjections(
-            ts, sourceFile, code, member, bridgeName, windowStageNames));
+            ts, sourceFile, code, member, bridgeName, windowStageNames, identifiers, resolve));
         }
       });
     }
     if (kind === 'stage' && !hasOnCreate) {
-      const indentation = classIndentation(code, node);
-      injections.push({
-        position: node.end - 1,
-        content: `\n${indentation}  onCreate(): void {\n` +
-          `${indentation}    ${bridgeName}.recordApplicationInit(this.context${pluginVersionArgument});\n` +
-          `${indentation}  }\n`
-      });
+      const inherited = inheritedState(node, 'onCreate');
+      if (!inherited.covered) {
+        const hook = `${bridgeName}.recordApplicationInit(this.context${pluginVersionArgument});`;
+        if (inherited.member) wrapInherited(node, 'onCreate', hook, false, inherited.member);
+        else injections.push({ position: node.end - 1,
+          content: `\n  onCreate(): void { ${hook} }\n` });
+      }
+    }
+    if (kind === 'ui' && !hasOnCreate) {
+      const inherited = inheritedState(node, 'onCreate');
+      if (!inherited.covered) {
+        launchTypes.needed = true;
+        if (inherited.member) {
+          wrapInherited(node, 'onCreate', `${bridgeName}.recordFirstUIAbilityCreate($launch, $want, this);`, true, inherited.member);
+        } else {
+          const wantName = selectIdentifierName(identifiers, '__ftLaunchWant');
+          const paramName = selectIdentifierName(identifiers, '__ftLaunchParam');
+          injections.push({ position: node.end - 1, content: `\n  onCreate(${wantName}: ${launchTypes.want}, ` +
+            `${paramName}: ${launchTypes.abilityConstant}.LaunchParam): void {\n` +
+            `    ${bridgeName}.recordFirstUIAbilityCreate(${paramName}, ${wantName}, this);\n  }\n` });
+        }
+      }
+    }
+    if (kind === 'ui') {
+      for (const [method, hook, exists] of [
+        ['onForeground', 'recordUIAbilityForeground', hasOnForeground],
+        ['onBackground', 'recordUIAbilityBackground', hasOnBackground],
+        ['onNewWant', 'recordUIAbilityNewWant', hasOnNewWant]
+      ]) {
+        if (exists) continue;
+        const inherited = inheritedState(node, method as string);
+        if (inherited.covered) continue;
+        const call = `${bridgeName}.${hook}(this);`;
+        if (inherited.member) wrapInherited(node, method as string, call, method === 'onNewWant', inherited.member);
+        else injections.push({ position: node.end - 1, content: `\n  ${method}(): void { ${call} }\n` });
+      }
     }
   });
-  return injections;
+  return { injections, hasUIAbility };
 }
 
 function applyColdLaunchInjections(code: string, injections: ColdLaunchInjection[]): string {
   const contentsByPosition = new Map<number, string[]>();
+  const ends = new Map<number, number>();
   injections.forEach((injection: ColdLaunchInjection) => {
     const contents = contentsByPosition.get(injection.position) || [];
     contents.push(injection.content);
     contentsByPosition.set(injection.position, contents);
+    ends.set(injection.position, Math.max(ends.get(injection.position) || injection.position, injection.end || injection.position));
   });
   const positions = Array.from(contentsByPosition.keys()).sort((left: number, right: number) => right - left);
   let transformedCode = code;
   positions.forEach((position: number) => {
     const content = (contentsByPosition.get(position) || []).join('');
-    transformedCode = transformedCode.slice(0, position) + content + transformedCode.slice(position);
+    transformedCode = transformedCode.slice(0, position) + content + transformedCode.slice(ends.get(position));
   });
   return transformedCode;
 }
 
-export function transformColdLaunchSource(ts: TypeScriptApi, id: string, code: string): string {
-  if (!isApplicationArkTsSource(id) || code.includes(COLD_LAUNCH_TRANSFORM_MARKER)) {
+export function transformColdLaunchSource(ts: TypeScriptApi, id: string, code: string,
+  readSource?: SourceReader): string {
+  if (!isApplicationArkTsSource(id) || code.includes(COLD_LAUNCH_TRANSFORM_MARKER) ||
+    !hasRuntimeDependency(ts, id, '@guancecloud/ft_sdk', readSource)) {
     return code;
   }
   const sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-  const bridgeName = selectBridgeName(collectIdentifierNames(ts, sourceFile));
+  const identifiers = collectIdentifierNames(ts, sourceFile);
+  const bridgeName = selectIdentifierName(identifiers, '__ftColdLaunchBridge');
+  const launchTypes: LaunchParameterTypes = {
+    want: selectIdentifierName(identifiers, '__ftLaunchWantType'),
+    abilityConstant: selectIdentifierName(identifiers, '__ftLaunchAbilityConstant'),
+    needed: false
+  };
   const version = getPluginVersion();
-  const injections = createColdLaunchInjections(ts, sourceFile, code, bridgeName, version);
-  if (injections.length === 0) {
+  const result = createColdLaunchInjections(ts, sourceFile, code, bridgeName, version, identifiers,
+    launchTypes, readSource);
+  const injections = result.injections;
+  const moduleFallback = result.hasUIAbility && needsUIAbilityModuleFallback(ts, id, readSource);
+  if (injections.length === 0 && !moduleFallback) {
     return code;
   }
-  const insertionOffset = findImportInsertionOffset(ts, sourceFile);
+  // Keep generated imports separate from initialization calls: ArkTS requires
+  // imports before other statements, while the no-Stage fallback must still
+  // run before executable application code.
+  const insertionOffset = moduleFallback
+    ? (code.startsWith('#!') ? code.indexOf('\n') + 1 : 0)
+    : findImportInsertionOffset(ts, sourceFile);
+  const firstApplicationStatement = sourceFile.statements.find((statement: any) => !ts.isImportDeclaration(statement));
+  const initializationOffset = moduleFallback && firstApplicationStatement
+    ? firstApplicationStatement.getStart(sourceFile) : insertionOffset;
+  const installBridgeName = selectIdentifierName(identifiers, '__ftColdLaunchInstallBridge');
+  const sdkName = selectIdentifierName(identifiers, '__ftColdLaunchSDK');
   const bridgeImport = `\n${COLD_LAUNCH_TRANSFORM_MARKER}\n` +
-    `import { FTColdLaunchBridge as ${bridgeName} } from '${COLD_LAUNCH_BRIDGE_IMPORT}';\n`;
-  const transformedCode = applyColdLaunchInjections(code, injections);
-  return transformedCode.slice(0, insertionOffset) + bridgeImport + transformedCode.slice(insertionOffset);
+    `import { FTColdLaunchBridge as ${bridgeName}, FTConsoleLogBridge as ${installBridgeName}` +
+    (version.length > 0 ? `, FTSDK as ${sdkName}` : '') + ` } from '${COLD_LAUNCH_BRIDGE_IMPORT}';\n` +
+    (launchTypes.needed ? `import { Want as ${launchTypes.want}, AbilityConstant as ${launchTypes.abilityConstant} } ` +
+      `from '@kit.AbilityKit';\n` : '');
+  const initialization = `\n${installBridgeName}.markCompilerPluginInstalled();\n` +
+    (version.length > 0 ? `${sdkName}.registerHvigorPluginVersion(${JSON.stringify(version)});\n` : '') +
+    (moduleFallback ? '// Application-init fallback: UIAbility module evaluation without an AbilityStage entry.\n' +
+      `${bridgeName}.recordApplicationInit(undefined, ${JSON.stringify(version)});\n` : '');
+  injections.push({ position: insertionOffset, content: bridgeImport });
+  injections.push({ position: initializationOffset, content: initialization });
+  return applyColdLaunchInjections(code, injections);
 }