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

package/hvigorCompile/ft-session-replay-transform.ts

@@ -0,0 +1,381 @@
+/**
+ * Guance Session Replay page-root compiler transform.
+ *
+ * ArkUI exposes a FrameNode only after a component has an ID.  The transform
+ * instruments @Entry page roots in Hvigor's in-memory source, leaving customer
+ * files untouched.  The generated calls are deliberately tiny: the optional
+ * Replay HAR owns root selection, layout retries, privacy, and capture.
+ */
+
+import { isApplicationArkTsSource } from './ft-console-log-transform';
+import { hasRuntimeDependency, SourceReader, SourceDiagnosticReporter, parseApplicationSource,
+  reportSourceDiagnostic, reportSourceParseError } from './ft-transform-context';
+import { allocateName as selectUniqueName } from './ft-generated-names';
+
+type TypeScriptApi = any;
+
+interface SourceRange {
+  start: number;
+  end: number;
+}
+
+interface MethodRange {
+  nameStart: number;
+  memberStart: number;
+  node: any;
+  bodyStart: number;
+  bodyEnd: number;
+}
+
+interface RootExpression {
+  end: number;
+  idArgument?: SourceRange;
+  hasAreaChange: boolean;
+  hasTouch: boolean;
+  touchArgument?: SourceRange;
+}
+
+interface EntryStruct {
+  node: any;
+  bodyEnd: number;
+  methods: Map<string, MethodRange>;
+}
+
+interface Injection {
+  position: number;
+  content: string;
+}
+
+const REPLAY_BRIDGE_IMPORT = '@guancecloud/ft_session_replay';
+const REPLAY_ROOT_TRANSFORM_MARKER = '/* guance-session-replay-root-transform:instrumented */';
+
+function lineIndentation(code: string, position: number): string {
+  const lineStart = code.lastIndexOf('\n', position) + 1;
+  const match = code.slice(lineStart, position).match(/^\s*/);
+  return match === null ? '' : match[0];
+}
+
+function collectIdentifiers(code: string): Set<string> {
+  const identifiers = new Set<string>();
+  const expression = /\b[A-Za-z_$][A-Za-z0-9_$]*\b/g;
+  let match: RegExpExecArray | null;
+  while ((match = expression.exec(code)) !== null) {
+    identifiers.add(match[0]);
+  }
+  return identifiers;
+}
+
+/** A stable opaque source key. Do not emit customers' project paths into UI IDs. */
+function createSourceKey(id: string): string {
+  let hash = 0x811c9dc5;
+  const normalized = id.replace(/\\/g, '/').toLowerCase();
+  for (let index = 0; index < normalized.length; index++) {
+    hash ^= normalized.charCodeAt(index);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return (hash >>> 0).toString(36);
+}
+
+function findImportInsertionOffset(ts: TypeScriptApi, id: string, code: string): number {
+  const sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true,
+    ts.ScriptKind.ETS ?? ts.ScriptKind.TS);
+  let offset = 0;
+  sourceFile.statements.forEach((statement: any): void => {
+    if (ts.isImportDeclaration(statement)) {
+      offset = statement.end;
+    }
+  });
+  return offset;
+}
+
+function findEntryDecorator(ts: TypeScriptApi, source: any): any {
+  let entry: any;
+  const visit = (node: any): void => {
+    if (ts.isDecorator(node)) {
+      const expression = ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
+      if (ts.isIdentifier(expression) && expression.text === 'Entry') entry ??= node;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return entry;
+}
+
+/** Structs, decorators and members must come from the ArkTS parser, never text matches. */
+function collectEntryStructs(ts: TypeScriptApi, source: any): EntryStruct[] {
+  const entries: EntryStruct[] = [];
+  source.statements.forEach((node: any) => {
+    if (!ts.isStructDeclaration(node)) return;
+    const decorators = ts.getDecorators ? ts.getDecorators(node) || [] : node.decorators || [];
+    const isEntry = decorators.some((decorator: any) => {
+      const expression = ts.isCallExpression(decorator.expression)
+        ? decorator.expression.expression : decorator.expression;
+      return ts.isIdentifier(expression) && expression.text === 'Entry';
+    });
+    if (!isEntry) return;
+    const methods = new Map<string, MethodRange>();
+    node.members.forEach((member: any) => {
+      if (ts.isMethodDeclaration(member) && member.body && ts.isIdentifier(member.name)) {
+        methods.set(member.name.text, { nameStart: member.name.getStart(source),
+          memberStart: member.getStart(source), node: member,
+          bodyStart: member.body.getStart(source), bodyEnd: member.body.end - 1 });
+      }
+    });
+    entries.push({ node, bodyEnd: node.end - 1, methods });
+  });
+  return entries;
+}
+
+function componentChain(ts: TypeScriptApi, expression: any): { base: any; modifiers: any[] } {
+  const modifiers: any[] = [];
+  let base = expression;
+  while (ts.isCallExpression(base) && ts.isPropertyAccessExpression(base.expression)) {
+    modifiers.unshift(base);
+    base = base.expression.expression;
+  }
+  return { base, modifiers };
+}
+
+function argumentRange(source: any, call: any): SourceRange {
+  // Include comments and newlines before the closing parenthesis when reusing an argument.
+  return { start: call.arguments.pos, end: call.getLastToken(source).getStart(source) };
+}
+
+function findRootExpression(ts: TypeScriptApi, source: any, code: string,
+  build: MethodRange): RootExpression | null {
+  const first = build.node.body.statements[0];
+  if (!first || (!ts.isExpressionStatement(first) && !ts.isReturnStatement(first)) || !first.expression) return null;
+  const { base, modifiers } = componentChain(ts, first.expression);
+  if (!ts.isEtsComponentExpression(base) || !base.body) return null;
+  let idArgument: SourceRange | undefined;
+  let hasAreaChange = false;
+  let hasTouch = false;
+  let touchArgument: SourceRange | undefined;
+  modifiers.forEach((call: any) => {
+    const name = call.expression.name.text;
+    const range = argumentRange(source, call);
+    if (name === 'id' && call.arguments.length === 1) {
+      const argument = call.arguments[0];
+      idArgument = { start: argument.getStart(source), end: argument.end };
+    }
+    if (name === 'onAreaChange') hasAreaChange = true;
+    if (name === 'onTouch') {
+      hasTouch = true;
+      if (call.arguments.length === 1) touchArgument = range;
+    }
+  });
+  return { end: first.expression.end, idArgument, hasAreaChange, hasTouch, touchArgument };
+}
+
+function applyInjections(code: string, injections: Injection[]): string {
+  const grouped = new Map<number, string[]>();
+  injections.forEach((injection: Injection): void => {
+    const values = grouped.get(injection.position) || [];
+    values.push(injection.content);
+    grouped.set(injection.position, values);
+  });
+  const positions = Array.from(grouped.keys()).sort((left: number, right: number): number => right - left);
+  let transformed = code;
+  positions.forEach((position: number): void => {
+    transformed = transformed.slice(0, position) + (grouped.get(position) || []).join('') + transformed.slice(position);
+  });
+  return transformed;
+}
+
+function addTransitionInjections(ts: TypeScriptApi, source: any, code: string, injections: Injection[],
+  entry: EntryStruct, bridgeName: string, tokenField: string, rootExpression: string): void {
+  const method = entry.methods.get('pageTransition');
+  if (!method) {
+    const indentation = `${lineIndentation(code, entry.bodyEnd)}  `;
+    injections.push({ position: entry.bodyEnd, content: `\n${indentation}pageTransition(): void {\n` +
+      `${indentation}  if (${bridgeName}.defaultTransitionStarted(this.${tokenField})) {}\n${indentation}}\n` });
+    return;
+  }
+  let nextSpec = 0;
+  method.node.body.statements.forEach((statement: any) => {
+    if (!ts.isExpressionStatement(statement)) return;
+    const { base, modifiers } = componentChain(ts, statement.expression);
+    if ((!ts.isCallExpression(base) && !ts.isEtsComponentExpression(base)) || !ts.isIdentifier(base.expression)) return;
+    const name = base.expression.text;
+    if (name !== 'PageTransitionEnter' && name !== 'PageTransitionExit') return;
+    const entering = name === 'PageTransitionEnter';
+    const callbackName = entering ? 'onEnter' : 'onExit';
+    const spec = JSON.stringify(`transition-${nextSpec++}`);
+    const prefix = `this.${tokenField}, ${rootExpression}, ${spec}, ${entering}`;
+    let callback: SourceRange | undefined;
+    modifiers.forEach((call: any) => {
+      const modifierName = call.expression.name.text;
+      const range = argumentRange(source, call);
+      if ((modifierName === 'slide' || modifierName === 'opacity') && call.arguments.length === 1) {
+        const hook = modifierName === 'slide' ? 'transitionSlide' : 'transitionOpacity';
+        injections.push({ position: range.start,
+          content: `${bridgeName}.${hook}(this.${tokenField}, ${spec}, ` });
+        injections.push({ position: range.end, content: ')' });
+      } else if (modifierName === callbackName && call.arguments.length === 1) callback = range;
+    });
+    if (callback) {
+      injections.push({ position: callback.start, content: `${bridgeName}.wrapTransition(${prefix}, ` });
+      injections.push({ position: callback.end, content: ')' });
+    } else {
+      injections.push({ position: statement.expression.end,
+        content: `.${callbackName}((type: RouteType, progress: number) => { ${bridgeName}.transitionProgress(${prefix}, progress); })` });
+    }
+  });
+}
+
+function lifecycleCall(bridgeName: string, tokenField: string, method: 'pageShown' | 'pageHidden' | 'pageDisposed',
+  rootExpression: string, observeDefaultTransition: boolean): string {
+  if (method === 'pageShown') {
+    return `${bridgeName}.pageShown(this.getUIContext(), this.${tokenField}, ${rootExpression}, vp2px(1), ${observeDefaultTransition});`;
+  }
+  return `${bridgeName}.${method}(this.${tokenField});`;
+}
+
+function addLifecycleInjection(
+  code: string,
+  injections: Injection[],
+  struct: EntryStruct,
+  buildMethod: MethodRange,
+  bridgeName: string,
+  tokenField: string,
+  methodName: 'onPageShow' | 'onPageHide' | 'aboutToDisappear',
+  runtimeMethod: 'pageShown' | 'pageHidden' | 'pageDisposed',
+  rootExpression: string,
+  visibleField?: string
+): void {
+  const existing = struct.methods.get(methodName);
+  const rawCall = lifecycleCall(bridgeName, tokenField, runtimeMethod, rootExpression,
+    !struct.methods.has('pageTransition'));
+  const call = !visibleField ? rawCall : methodName === 'onPageShow'
+    ? `this.${visibleField} = true; if (${rootExpression}.length > 0) { ${rawCall} }`
+    : `this.${visibleField} = false; ${rawCall}`;
+  if (existing) {
+    const indentation = `${lineIndentation(code, existing.nameStart)}  `;
+    injections.push({ position: existing.bodyStart + 1, content: `\n${indentation}${call}` });
+    return;
+  }
+  const indentation = lineIndentation(code, buildMethod.nameStart);
+  injections.push({
+    position: buildMethod.memberStart,
+    content: `\n${indentation}${methodName}(): void {\n${indentation}  ${call}\n${indentation}}\n\n`
+  });
+}
+
+/**
+ * Adds an opaque root ID and page lifecycle registration to every @Entry page.
+ * ArkTS nodes locate real decorators, struct members and component expressions.
+ */
+export function transformSessionReplaySource(ts: TypeScriptApi, id: string, code: string, readSource?: SourceReader,
+  reportDiagnostic?: SourceDiagnosticReporter): string {
+  if (!isApplicationArkTsSource(id) || code.includes(REPLAY_ROOT_TRANSFORM_MARKER) ||
+    !hasRuntimeDependency(ts, id, '@guancecloud/ft_sdk', readSource) ||
+    !hasRuntimeDependency(ts, id, REPLAY_BRIDGE_IMPORT, readSource)) {
+    return code;
+  }
+
+  const preliminarySource = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true,
+    ts.ScriptKind.ETS ?? ts.ScriptKind.TS);
+  const report = (source: any, position: number, reason: string, message: string): void => {
+    reportSourceDiagnostic(source, position, reason, message, reportDiagnostic);
+  };
+  if (typeof ts.isStructDeclaration !== 'function' || typeof ts.isEtsComponentExpression !== 'function') {
+    // Even a standard TypeScript parser retains real decorator nodes. Do not
+    // mistake @Entry text inside comments or strings for a page needing Replay.
+    const entryDecorator = findEntryDecorator(ts, preliminarySource);
+    if (entryDecorator) report(preliminarySource, entryDecorator.getStart(preliminarySource), 'unsupported-parser',
+      'The installed compiler does not expose the ArkTS struct/component parser required for automatic Replay roots.');
+    return code;
+  }
+  const source = parseApplicationSource(ts, id, code, preliminarySource);
+  const entries = collectEntryStructs(ts, source);
+  if (entries.length === 0 && !findEntryDecorator(ts, source)) return code;
+  if (reportSourceParseError(ts, source, reportDiagnostic)) return code;
+
+  const identifiers = collectIdentifiers(code);
+  const bridgeName = selectUniqueName(identifiers, '__ftSessionReplayAutoRootBridge');
+  const tokenField = selectUniqueName(identifiers, '__ftSessionReplayRootToken');
+  const sourceKey = createSourceKey(id);
+  const injections: Injection[] = [];
+
+  entries.forEach((entry: EntryStruct): void => {
+    const buildMethod = entry.methods.get('build');
+    if (!buildMethod) {
+      report(source, entry.node.name.getStart(source), 'missing-build',
+        'The @Entry page has no build() method with a body to instrument.');
+      return;
+    }
+    const root = findRootExpression(ts, source, code, buildMethod);
+    if (root === null) {
+      const first = buildMethod.node.body.statements[0];
+      report(source, first ? first.getStart(source) : buildMethod.bodyStart + 1, 'unsupported-root',
+        'build() must start with a supported ArkUI root component with a child block for automatic Replay registration.');
+      return;
+    }
+    const indentation = lineIndentation(code, buildMethod.nameStart);
+    injections.push({
+      position: buildMethod.memberStart,
+      content: `\n${indentation}private ${tokenField}: string = ${bridgeName}.createRootToken(${JSON.stringify(sourceKey)});\n\n`
+    });
+
+    let rootExpression = `this.${tokenField}`;
+    let visibleField: string | undefined;
+    if (root.idArgument) {
+      const idField = selectUniqueName(identifiers, '__ftSessionReplayRootId');
+      visibleField = selectUniqueName(identifiers, '__ftSessionReplayVisible');
+      const capture = selectUniqueName(identifiers, '__ftSessionReplayCaptureId');
+      const value = selectUniqueName(identifiers, '__ftSessionReplayIdValue');
+      rootExpression = `this.${idField}`;
+      const shown = lifecycleCall(bridgeName, tokenField, 'pageShown', rootExpression,
+        !entry.methods.has('pageTransition'));
+      injections.push({ position: buildMethod.memberStart,
+        content: `\n${indentation}private ${idField}: string = '';\n` +
+          `${indentation}private ${visibleField}: boolean = false;\n` +
+          `${indentation}private ${capture}(${value}: string): string {\n` +
+          `${indentation}  const changed: boolean = this.${idField} !== ${value};\n` +
+          `${indentation}  this.${idField} = ${value};\n` +
+          `${indentation}  if (changed && this.${visibleField} && ${value}.length > 0) { ${shown} }\n` +
+          `${indentation}  return ${value};\n${indentation}}\n` });
+      injections.push({ position: root.idArgument.start, content: `this.${capture}(` });
+      injections.push({ position: root.idArgument.end, content: ')' });
+    } else {
+      injections.push({ position: root.end, content: `.id(${rootExpression})` });
+    }
+    // Root area changes are ArkUI's public layout/draw boundary. Emit a
+    // coalesced Replay signal there instead of installing a fixed full-tree
+    // polling loop. Do not add a second modifier when an app already owns one.
+    if (!root.hasAreaChange) {
+      injections.push({
+        position: root.end,
+        content: `.onAreaChange(() => { ${bridgeName}.pageChanged(this.${tokenField}); })`
+      });
+    }
+    // Preserve application callbacks and their event propagation behavior.
+    // The bridge forwards real pointer coordinates independently of drawing.
+    if (!root.hasTouch) {
+      injections.push({
+        position: root.end,
+        content: `.onTouch((event: TouchEvent) => { ${bridgeName}.pageTouch(this.${tokenField}, event); })`
+      });
+    } else if (root.touchArgument !== undefined) {
+      injections.push({ position: root.touchArgument.start,
+        content: `${bridgeName}.wrapTouch(this.${tokenField}, ` });
+      injections.push({ position: root.touchArgument.end, content: ')' });
+    }
+    addLifecycleInjection(code, injections, entry, buildMethod, bridgeName, tokenField,
+      'onPageShow', 'pageShown', rootExpression, visibleField);
+    addLifecycleInjection(code, injections, entry, buildMethod, bridgeName, tokenField,
+      'onPageHide', 'pageHidden', rootExpression, visibleField);
+    addLifecycleInjection(code, injections, entry, buildMethod, bridgeName, tokenField,
+      'aboutToDisappear', 'pageDisposed', rootExpression, visibleField);
+    addTransitionInjections(ts, source, code, injections, entry, bridgeName, tokenField, rootExpression);
+  });
+
+  if (injections.length === 0) {
+    return code;
+  }
+  const importOffset = findImportInsertionOffset(ts, id, code);
+  const importStatement = `\n${REPLAY_ROOT_TRANSFORM_MARKER}\n` +
+    `import { FTSessionReplayAutoRootBridge as ${bridgeName} } from '${REPLAY_BRIDGE_IMPORT}';\n`;
+  injections.push({ position: importOffset, content: importStatement });
+  return applyInjections(code, injections);
+}

package/hvigorCompile/ft-source-transform-host.ts

@@ -12,6 +12,9 @@ import {
   transformConsoleLogSource
 } from './ft-console-log-transform';
 import { transformColdLaunchSource } from './ft-cold-launch-transform';
+import { transformSessionReplaySource } from './ft-session-replay-transform';
+import { transformWebReplaySource } from './ft-web-replay-transform';
+import { SourceDiagnosticReporter, SourceTransformDiagnostic } from './ft-transform-context';
 
 declare const require: {
   main: {
@@ -20,7 +23,9 @@ declare const require: {
 };
 
 type TypeScriptApi = any;
-type SourceTransform = (ts: TypeScriptApi, fileName: string, code: string) => string;
+type SourceReader = (fileName: string) => string | undefined;
+type SourceTransform = (ts: TypeScriptApi, fileName: string, code: string, readSource?: SourceReader,
+  reportDiagnostic?: SourceDiagnosticReporter) => string;
 
 interface CompilePluginContext {
   share: {
@@ -32,6 +37,8 @@ interface CompilePluginContext {
 
 interface SourceTransformDefinition {
   id: string;
+  prefix: string;
+  feature: string;
   transform: SourceTransform;
 }
 
@@ -39,21 +46,64 @@ interface SharedSourceTransformRegistry {
   originalReadFile: (fileName: string, options?: any) => any;
   buffer: any;
   transforms: Map<string, (fileName: string, code: string) => string>;
+  owners: Map<object, Map<string, (fileName: string, code: string) => string>>;
+  reportedDiagnostics: Set<string>;
 }
 
 const SOURCE_TRANSFORM_REGISTRY_KEY = '__guanceHvigorSourceTransformRegistry';
 const SOURCE_TRANSFORMS: SourceTransformDefinition[] = [
-  { id: 'guance-console-log-transform', transform: transformConsoleLogSource },
-  { id: 'guance-cold-launch-transform', transform: transformColdLaunchSource }
+  { id: 'guance-console-log-transform', prefix: 'GuanceLog', feature: 'console-log', transform: transformConsoleLogSource },
+  { id: 'guance-cold-launch-transform', prefix: 'GuanceColdLaunch', feature: 'cold-launch', transform: transformColdLaunchSource },
+  { id: 'guance-session-replay-root-transform', prefix: 'GuanceReplay', feature: 'session-replay-root', transform: transformSessionReplaySource },
+  { id: 'guance-web-replay-transform', prefix: 'GuanceWebReplay', feature: 'web-replay', transform: transformWebReplaySource }
 ];
 
-let registeredFileSystem: any = null;
+const registrations: Array<{ fileSystem: any; owner: object; context: CompilePluginContext }> = [];
 
-function installSourceReader(context: CompilePluginContext): void {
-  if (registeredFileSystem !== null) {
-    return;
-  }
+function refreshTransforms(registry: SharedSourceTransformRegistry): void {
+  registry.transforms.clear();
+  registry.owners.forEach(transforms => transforms.forEach((transform, id) => registry.transforms.set(id, transform)));
+}
+
+function createDiagnosticReporter(registry: SharedSourceTransformRegistry, ts: TypeScriptApi,
+  readSource: SourceReader, definition: SourceTransformDefinition):
+  (diagnostic: SourceTransformDiagnostic, inputFile: string, inputCode: string, occurrence?: number) => void {
+  let logger: { warn(message: string): void } | undefined;
+  return (diagnostic: SourceTransformDiagnostic, inputFile: string, inputCode: string, occurrence = 0): void => {
+    // Earlier transforms can insert imports or wrappers. Recheck only failed
+    // pages against the on-disk source so clickable locations refer to app code.
+    const originalCode = readSource(diagnostic.fileName);
+    if (diagnostic.reason !== 'transform-exception' && diagnostic.fileName === inputFile &&
+      originalCode !== undefined && originalCode !== inputCode) {
+      const originalDiagnostics: SourceTransformDiagnostic[] = [];
+      try {
+        definition.transform(ts, diagnostic.fileName, originalCode, readSource, candidate => {
+          if (candidate.reason === diagnostic.reason &&
+            (candidate.message === diagnostic.message || candidate.reason === 'parse-error')) originalDiagnostics.push(candidate);
+        });
+      } catch (_) {
+        // Location mapping is diagnostic-only and must not change build behavior.
+      }
+      diagnostic = originalDiagnostics[occurrence] ?? { ...diagnostic,
+        message: `${diagnostic.message} (Location refers to in-memory transformed source.)` };
+    }
+    const key = `${definition.id}:${JSON.stringify(diagnostic)}`;
+    if (registry.reportedDiagnostics.has(key)) return;
+    registry.reportedDiagnostics.add(key);
+    const message = `[GuanceBuild][${definition.prefix}] ${diagnostic.fileName}:${diagnostic.line}:${diagnostic.column}: ` +
+      `feature=${definition.feature}; reason=${diagnostic.reason}; ${diagnostic.message}`;
+    if (!logger) {
+      try {
+        logger = require.main.require('@ohos/hvigor').HvigorLogger.getLogger(definition.prefix);
+      } catch (_) {
+        logger = { warn: (value: string): void => console.warn(value) };
+      }
+    }
+    logger!.warn(message);
+  };
+}
 
+function installSourceReader(context: CompilePluginContext): void {
   const typeScriptPath = `${context.share.projectConfig.etsLoaderPath}/node_modules/typescript`;
   const ts = require.main.require(typeScriptPath);
   const fileSystem = require.main.require('fs');
@@ -62,7 +112,9 @@ function installSourceReader(context: CompilePluginContext): void {
     registry = {
       originalReadFile: fileSystem.readFileSync as (fileName: string, options?: any) => any,
       buffer: require.main.require('buffer'),
-      transforms: new Map<string, (fileName: string, code: string) => string>()
+      transforms: new Map<string, (fileName: string, code: string) => string>(),
+      owners: new Map(),
+      reportedDiagnostics: new Set()
     };
     fileSystem[SOURCE_TRANSFORM_REGISTRY_KEY] = registry;
     fileSystem.readFileSync = (fileName: string, options?: any): any => {
@@ -78,26 +130,63 @@ function installSourceReader(context: CompilePluginContext): void {
     };
   }
 
+  const readSource: SourceReader = (fileName: string): string | undefined => {
+    try {
+      return registry!.originalReadFile(fileName, 'utf8').toString();
+    } catch (_) {
+      return undefined;
+    }
+  };
+  // A daemon may retain a registry installed by an earlier plugin version.
+  registry.reportedDiagnostics ??= new Set();
+  const owner = {};
+  const transforms = new Map<string, (fileName: string, code: string) => string>();
   SOURCE_TRANSFORMS.forEach((definition: SourceTransformDefinition) => {
-    registry!.transforms.set(definition.id, (fileName: string, code: string) =>
-      definition.transform(ts, fileName, code));
+    const reportDiagnostic = createDiagnosticReporter(registry!, ts, readSource, definition);
+    transforms.set(definition.id, (fileName: string, code: string) => {
+      const occurrences = new Map<string, number>();
+      try {
+        return definition.transform(ts, fileName, code, readSource,
+          diagnostic => {
+            const key = `${diagnostic.reason}:${diagnostic.message}`;
+            const occurrence = occurrences.get(key) ?? 0;
+            occurrences.set(key, occurrence + 1);
+            reportDiagnostic(diagnostic, fileName, code, occurrence);
+          });
+      } catch (error) {
+        try {
+          reportDiagnostic({ fileName, line: 1, column: 1, reason: 'transform-exception',
+            message: `Source transform failed: ${error instanceof Error ? error.message : String(error)}` }, fileName, code);
+        } finally {
+          // Preserve the original failure: diagnostics must never turn a broken
+          // transform into a successful build or replace its exception.
+          throw error;
+        }
+      }
+    });
   });
-  registeredFileSystem = fileSystem;
+  registry.owners.set(owner, transforms);
+  refreshTransforms(registry);
+  registrations.push({ fileSystem, owner, context });
 }
 
-function restoreSourceReader(): void {
-  if (registeredFileSystem === null) {
-    return;
+function restoreSourceReader(context: CompilePluginContext): void {
+  let index = registrations.length - 1;
+  for (let candidate = registrations.length - 1; candidate >= 0; candidate--) {
+    if (registrations[candidate].context === context) { index = candidate; break; }
   }
-  const registry = registeredFileSystem[SOURCE_TRANSFORM_REGISTRY_KEY] as SharedSourceTransformRegistry | undefined;
+  const registration = index < 0 ? undefined : registrations.splice(index, 1)[0];
+  if (!registration) return;
+  const { fileSystem, owner } = registration;
+  const registry = fileSystem[SOURCE_TRANSFORM_REGISTRY_KEY] as SharedSourceTransformRegistry | undefined;
   if (registry) {
-    SOURCE_TRANSFORMS.forEach((definition: SourceTransformDefinition) => registry!.transforms.delete(definition.id));
-    if (registry.transforms.size === 0) {
-      registeredFileSystem.readFileSync = registry.originalReadFile;
-      delete registeredFileSystem[SOURCE_TRANSFORM_REGISTRY_KEY];
+    registry.owners.delete(owner);
+    refreshTransforms(registry);
+    if (registry.owners.size === 0) {
+      fileSystem.readFileSync = registry.originalReadFile;
+      delete fileSystem[SOURCE_TRANSFORM_REGISTRY_KEY];
     }
   }
-  registeredFileSystem = null;
 }
 
 export default {
@@ -106,7 +195,7 @@ export default {
   buildStart(this: CompilePluginContext): void {
     installSourceReader(this);
   },
-  buildEnd(): void {
-    restoreSourceReader();
+  buildEnd(this: CompilePluginContext): void {
+    restoreSourceReader(this);
   }
 };

package/hvigorCompile/ft-transform-context.ts

@@ -0,0 +1,91 @@
+/** Shared, source-module-specific guards for compiler transforms. */
+declare const require: any;
+
+export type SourceReader = (fileName: string) => string | undefined;
+
+export interface SourceTransformDiagnostic {
+  fileName: string;
+  line: number;
+  column: number;
+  reason: string;
+  message: string;
+}
+
+export type SourceDiagnosticReporter = (diagnostic: SourceTransformDiagnostic) => void;
+
+export function reportSourceDiagnostic(source: any, position: number, reason: string, message: string,
+  reporter?: SourceDiagnosticReporter): void {
+  if (!reporter) return;
+  const location = source.getLineAndCharacterOfPosition(position);
+  reporter({ fileName: source.fileName, line: location.line + 1, column: location.character + 1, reason, message });
+}
+
+/** Parse declarative child blocks without treating enum members as components. */
+export function parseApplicationSource(ts: any, id: string, code: string, preliminary?: any): any {
+  const source = preliminary ?? ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true,
+    ts.ScriptKind.ETS ?? ts.ScriptKind.TS);
+  if (!id.endsWith('.ets') || typeof ts.isStructDeclaration !== 'function' ||
+    typeof ts.isEtsComponentExpression !== 'function') return source;
+  const names = new Set<string>();
+  const visit = (node: any): void => {
+    if ((ts.isCallExpression(node) || ts.isEtsComponentExpression(node)) && ts.isIdentifier(node.expression)) {
+      names.add(node.expression.text);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  const components = Array.from(names).filter(name => !['ForEach', 'LazyForEach', 'Repeat'].includes(name));
+  return ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true, ts.ScriptKind.ETS, { ets: {
+    components,
+    render: { method: ['build', 'pageTransition'], decorator: ['Builder', 'LocalBuilder'] },
+    extend: { decorator: ['Extend', 'AnimatableExtend'], components: components.map(name =>
+      ({ name, type: `${name}Attribute`, instance: `${name}Instance` })) },
+    styles: { decorator: 'Styles', component: { name: 'Common', type: 'T', instance: 'CommonInstance' }, property: 'stateStyles' },
+    concurrent: { decorator: 'Concurrent' },
+    customComponent: 'CustomComponent',
+    syntaxComponents: { paramsUICallback: ['ForEach', 'LazyForEach'],
+      attrUICallback: [{ name: 'Repeat', attributes: ['each', 'template'] }] }
+  } });
+}
+
+export function reportSourceParseError(ts: any, source: any, reporter?: SourceDiagnosticReporter): boolean {
+  if (source.parseDiagnostics.length === 0) return false;
+  const diagnostic = source.parseDiagnostics[0];
+  const remaining = source.parseDiagnostics.length - 1;
+  reportSourceDiagnostic(source, diagnostic.start ?? 0, 'parse-error',
+    `TS${diagnostic.code}: ${ts.flattenDiagnosticMessageText(diagnostic.messageText, ' ')}${
+      remaining > 0 ? ` (${remaining} additional parse errors)` : ''}`, reporter);
+  return true;
+}
+
+export function objectProperty(ts: any, 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;
+}
+
+/** Read JSON5 as data syntax, without evaluating package contents. */
+export function hasRuntimeDependency(ts: any, id: string, packageName: string, readSource?: SourceReader): boolean {
+  const normalized = id.replace(/\\/g, '/');
+  const sourceIndex = normalized.lastIndexOf('/src/main/ets/');
+  if (sourceIndex < 0) return false;
+  const packagePath = normalized.slice(0, sourceIndex) + '/oh-package.json5';
+  try {
+    const nodeRequire = require.main && typeof require.main.require === 'function'
+      ? require.main.require.bind(require.main) : require;
+    const code = readSource ? readSource(packagePath) : nodeRequire('fs').readFileSync(packagePath, 'utf8');
+    if (typeof code !== 'string') return false;
+    const parsed = ts.createSourceFile(packagePath, `const __package = ${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 dependency = objectProperty(ts, objectProperty(ts, root, 'dependencies'), packageName);
+    // Runtime imports require an explicit dependency in the owning module.
+    // Do not inherit the entry/root module's dependencies or match comments/devDependencies.
+    return !!dependency && ts.isStringLiteral(dependency) && dependency.text.trim().length > 0;
+  } catch (_) {
+    return false;
+  }
+}