@idlizer/arktscgen 2.1.10-arktscgen-5 → 2.1.10-arktscgen-6

package/build/libarkts-copy/src/arkts-api/plugins.ts

@@ -19,6 +19,7 @@ import { ExternalSource } from './peers/ExternalSource';
 import { KNativePointer, nullptr } from '@koalaui/interop';
 import { global } from './static/global';
 import { RunTransformerHooks } from '../plugin-utils';
+import { Context } from './peers/Context';
 
 export interface CompilationOptions {
     readonly isProgramForCodegeneration: boolean;
@@ -62,16 +63,32 @@ export interface ProjectConfig {
     isUi2abc?: boolean;
 }
 
-export interface PluginContext {
+export interface PluginContextBase {
     setParameter<V>(name: string, value: V): void;
     parameter<V>(name: string): V | undefined;
 }
 
-export class PluginContextImpl implements PluginContext {
-    map = new Map<string, object | undefined>();
+export interface PluginContext extends PluginContextBase {
+    /**
+     * @deprecated
+     */
+    setArkTSProgram(program: Program): void
 
-    private ast: ETSModule | undefined = undefined;
-    private projectConfig: ProjectConfig | undefined = undefined;
+    /**
+     * @deprecated
+     */
+    getArkTSProgram(): Program | undefined
+
+    setCodingFilePath(codingFilePath: string): void
+
+    getCodingFilePath(): string | undefined
+
+    isCoding(): boolean
+}
+
+
+export class PluginContextBaseImpl implements PluginContextBase {
+    map = new Map<string, object | undefined>();
 
     parameter<V>(name: string): V | undefined {
         return this.map.get(name) as V | undefined;
@@ -79,9 +96,38 @@ export class PluginContextImpl implements PluginContext {
     setParameter<V>(name: string, value: V): void {
         this.map.set(name, value as object);
     }
+}
+
+// Temporary hack to use plugin context's parameters when compiling with driver
+export function extendPluginContext(context: PluginContextImpl) {
+    if (typeof context.setParameter == "function") {
+        return
+    }
+    const pluginContextBaseImpl = new PluginContextBaseImpl()
+    context.map = pluginContextBaseImpl.map
+    context.setParameter = pluginContextBaseImpl.setParameter
+    context.parameter = pluginContextBaseImpl.parameter
+}
+
+export class PluginContextImpl extends PluginContextBaseImpl implements PluginContext {
+    private ast: ETSModule | undefined;
+    private projectConfig: ProjectConfig | undefined;
+
+    private program: Program | undefined;
+    private codingFilePath: string | undefined;
+
+    setContextPtr(ptr: KNativePointer): void {
+        if (!global.compilerContext) {
+            global.compilerContext = new Context(ptr);
+        } else {
+            global.compilerContext.peer = ptr;
+        }
+    }
+
     getContextPtr(): KNativePointer {
         return global.compilerContext?.peer ?? nullptr;
     }
+
     public setProjectConfig(projectConfig: ProjectConfig): void {
         this.projectConfig = projectConfig;
     }
@@ -102,14 +148,73 @@ export class PluginContextImpl implements PluginContext {
     public getArkTSAst(): ETSModule | undefined {
         return this.ast;
     }
+
+    /**
+     * @deprecated
+     */
+    public setArkTSProgram(program: Program): void {
+        this.program = program;
+    }
+
+    /**ProjectConfig
+     * @deprecated
+     */
+    public getArkTSProgram(): Program | undefined {
+        return this.program;
+    }
+
+    public setCodingFilePath(codingFilePath: string): void {
+        this.codingFilePath = codingFilePath;
+    }
+
+    public getCodingFilePath(): string | undefined {
+        return this.codingFilePath;
+    }
+
+    public isCoding(): boolean {
+        return this.codingFilePath !== undefined;
+    }
 }
 
+export type PluginHandlerFunction = () => void;
+
+export type PluginHandlerObject = {
+    order: 'pre' | 'post' | undefined;
+    handler: PluginHandlerFunction;
+};
+
+export type PluginHandler = PluginHandlerFunction | PluginHandlerObject;
+
 export type ProgramTransformer = (
     program: Program,
     compilationOptions: CompilationOptions,
     context: PluginContext
 ) => void;
 
+export interface Plugins {
+    name: string;
+    afterNew?: PluginHandler;
+    parsed?: PluginHandler;
+    scopeInited?: PluginHandler;
+    checked?: PluginHandler;
+    lowered?: PluginHandler;
+    asmGenerated?: PluginHandler;
+    binGenerated?: PluginHandler;
+    clean?: PluginHandler;
+}
+
+export type PluginState = keyof Omit<Plugins, 'name'>;
+
+export type PluginExecutor = {
+    name: string;
+    handler: PluginHandlerFunction;
+};
+
+export interface BuildConfig {
+    compileFiles: string[];
+}
+
+
 export function defaultFilter(name: string): boolean {
     if (name.startsWith('std.')) return false;
     if (name.startsWith('escompat')) return false;

package/build/libarkts-copy/src/arkts-api/static/global.ts

@@ -54,7 +54,7 @@ export class global {
         return global._config ?? throwError('Global.config not initialized');
     }
     public static configIsInitialized(): boolean {
-        return global._config !== undefined && global._config !== nullptr;
+        return !!global._config && global._config !== nullptr;
     }
     public static resetConfig(): void {
         global._config = undefined;

package/build/libarkts-copy/src/arkts-api/static/profiler.ts

@@ -80,7 +80,7 @@ export class Profiler implements PerformanceData {
         return this.pluginsByName[pluginName];
     }
 
-    disableReport = false;
+    disableReport = true;
 
     nodeCreated() {
         this.createdNodes++;

package/build/libarkts-copy/src/arkts-api/utilities/performance.ts

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+const { performance } = require('perf_hooks');
 import * as process from 'process';
 import { global as localGlobal } from '../static/global';
 
@@ -286,7 +287,7 @@ export class Performance {
             '[PERFORMANCE]',
             `External       | ${context.startMemory.external.toFixed(2)}    | ${(endMemory.external / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.external.toFixed(2)}`
         );
-        if (endMemory.arrayBuffers !== undefined) {
+        if (!!endMemory.arrayBuffers) {
             console.log(
                 `Array Buffers  | ${context.startMemory.arrayBuffers.toFixed(2)}    | ${((endMemory.arrayBuffers || 0) / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.arrayBuffers.toFixed(2)}`
             );

package/build/libarkts-copy/src/arkts-api/utilities/private.ts

@@ -17,7 +17,6 @@ import { global } from '../static/global';
 import { isNumber, throwError } from '../../utils';
 import { KInt, KNativePointer as KPtr, KNativePointer, nullptr, withString, withStringArray } from '@koalaui/interop';
 import { NativePtrDecoder } from './nativePtrDecoder';
-//import { OptimizedNativePtrDecoder as NativePtrDecoder } from "./nativePtrDecoder"
 import {
     Es2pandaAstNodeType,
     Es2pandaModifierFlags,
@@ -71,13 +70,9 @@ export function acceptNativeObjectArrayResult<T extends ArktsObject>(
     arrayObject: KNativePointer,
     factory: (instance: KNativePointer) => T
 ): T[] {
-    // For OptimizedNativePtrDecoder
-    //const decoded = new NativePtrDecoder().decode(arrayObject)
-    //return decoded.reduce((prev, curr) => {
-    //    prev.push(factory(curr))
-    //    return prev
-    //}, [] as T[])
-    return new NativePtrDecoder().decode(arrayObject).map(factory);
+    // OptimizedNativePtrDecoder:return decoded.reduce((prev, curr)=>{prev.push(factory(curr));return prev},[] as T[])
+    const decoded = new NativePtrDecoder().decode(arrayObject)
+    return decoded.map(factory);
 }
 
 export function unpackNonNullableNode<T extends AstNode>(peer: KNativePointer, typeHint?: Es2pandaAstNodeType): T {
@@ -112,7 +107,7 @@ export function unpackNodeArray<T extends AstNode>(nodesPtr: KNativePointer, typ
 }
 
 export function passNodeArray(nodes: readonly ArktsObject[] | undefined): BigUint64Array {
-    return new BigUint64Array(nodes?.filter((it) => it.peer != undefined)?.map((node) => BigInt(node.peer)) ?? []);
+    return new BigUint64Array(nodes?.filter((it) => (!!it.peer))?.map((node) => BigInt(node.peer)) ?? []);
 }
 
 export function unpackString(peer: KNativePointer): string {

package/build/libarkts-copy/src/arkts-api/utilities/public.ts

@@ -63,13 +63,13 @@ import {
     MemberExpression,
     isMethodDefinition,
     TypeNode,
+    DiagnosticKind
 } from '../../../generated';
 import { Config } from '../peers/Config';
 import { Context } from '../peers/Context';
 import { NodeCache } from '../node-cache';
 import { factory } from '../factory/nodeFactory';
 import { traceGlobal } from '../../tracer';
-import { DiagnosticKind } from '../peers/DiagnosticKind';
 
 /**
  * Improve: Replace or remove with better naming
@@ -78,11 +78,11 @@ import { DiagnosticKind } from '../peers/DiagnosticKind';
  */
 export function createETSModuleFromContext(): ETSModule {
     let program = global.generatedEs2panda._ContextProgram(global.context);
-    if (program == nullptr) {
+    if (program === nullptr || program === null) {
         throw new Error(`Program is null for context ${global.context.toString(16)}`);
     }
     const ast = global.generatedEs2panda._ProgramAst(global.context, program);
-    if (ast == nullptr) {
+    if (ast === nullptr || ast === null) {
         throw new Error(`AST is null for program ${program.toString(16)}`);
     }
     return new ETSModule(ast, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE);
@@ -122,10 +122,19 @@ export function checkErrors() {
         traceGlobal(() => `Terminated due to compilation errors occured`);
         console.log(unpackString(global.generatedEs2panda._GetAllErrorMessages(global.context)));
         // global.es2panda._DestroyConfig(global.config)
-        process.exit(1);
+        throw new Error(`Compilation error`)
     }
 }
 
+function format(value: number): string {
+    return `${(value / 1024 / 1024 / 1024).toFixed(4)} GB`
+}
+
+// Improve: move to profiler
+function dumpMemoryProfilerInfo(str: string) {
+    console.log(str, format(process.memoryUsage().rss));
+}
+
 export function proceedToState(state: Es2pandaContextState): void {
     if (state <= global.es2panda._ContextState(global.context)) {
         return;
@@ -137,6 +146,9 @@ export function proceedToState(state: Es2pandaContextState): void {
     traceGlobal(() => `Proceeding to state ${Es2pandaContextState[state]}: done`);
     const after = Date.now();
     global.profiler.proceededToState(after - before);
+    if (state == Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED) {
+        dumpMemoryProfilerInfo("Memory usage (rss) after proceed to bin:")
+    }
     checkErrors();
 }
 
@@ -372,7 +384,7 @@ export function generateTsDeclarationsFromContext(
     recordFile: string,
     genAnnotations: boolean
 ): KInt {
-    return global.es2panda._GenerateTsDeclarationsFromContext(
+    return global.generatedEs2panda._GenerateTsDeclarationsFromContext(
         global.context,
         passString(outputDeclEts),
         passString(outputEts),
@@ -451,7 +463,7 @@ export function createDiagnosticInfo(
     ...args: string[]
 ): DiagnosticInfo {
     return new DiagnosticInfo(
-        global.es2panda._CreateDiagnosticInfo(
+        global.generatedEs2panda._CreateDiagnosticInfo(
             global.context,
             kind.peer,
             passStringArray(args),
@@ -469,7 +481,7 @@ export function createSuggestionInfo(
     ...args: string[]
 ): SuggestionInfo {
     return new SuggestionInfo(
-        global.es2panda._CreateSuggestionInfo(
+        global.generatedEs2panda._CreateSuggestionInfo(
             global.context,
             kind.peer,
             passStringArray(args),
@@ -493,6 +505,26 @@ export function logDiagnosticWithSuggestion(diagnosticInfo: DiagnosticInfo, sugg
     global.generatedEs2panda._LogDiagnosticWithSuggestion(global.context, diagnosticInfo.peer, suggestionInfo.peer);
 }
 
-export function filterNodes(node: AstNode, filter: string): AstNode[] {
-    return unpackNodeArray(global.es2panda._FilterNodes(global.context, passNode(node), filter));
+export function filterNodes(node: AstNode, filter: string, deeperAfterMatch: boolean): AstNode[] {
+    return unpackNodeArray(global.es2panda._FilterNodes(global.context, passNode(node), filter, deeperAfterMatch));
+}
+
+export function filterNodesByType<T extends AstNode = AstNode>(node: AstNode, type: Es2pandaAstNodeType): T[] {
+    return unpackNodeArray(global.es2panda._FilterNodes2(global.context, passNode(node), type), type);
+}
+
+export function filterNodesByTypes(node: AstNode, types: Es2pandaAstNodeType[]): AstNode[] {
+    const typesArray = new Int32Array(types.length)
+    for (let i = 0; i < types.length; i++) {
+        typesArray[i] = types[i]
+    }
+    return unpackNodeArray(global.es2panda._FilterNodes3(global.context, passNode(node), typesArray, types.length));
+}
+
+export function MemInitialize() {
+    global.es2panda._MemInitialize()
+}
+
+export function MemFinalize() {
+    global.es2panda._MemFinalize()
 }

package/build/libarkts-copy/src/arkts-api/visitor.ts

@@ -258,34 +258,17 @@ function visitETSTypeReferencePart(node: ETSTypeReferencePart, visitor: Visitor)
 function visitScriptFunction(node: ScriptFunction, visitor: Visitor): ScriptFunction {
     global.updateTracker.push();
     const newBody = nodeVisitor(node.body, visitor);
-    const oldTypeParams = node.typeParams;
-    const newTypeParams = nodeVisitor(oldTypeParams, visitor);
+    const newTypeParams = nodeVisitor(node.typeParams, visitor);
     const newParams: readonly Expression[] = nodesVisitor(node.params, visitor);
     const newReturnTypeAnnotation = nodeVisitor(node.returnTypeAnnotation, visitor);
     const newId = nodeVisitor(node.id, visitor);
     const newAnnotations: readonly AnnotationUsage[] = nodesVisitor(node.annotations, visitor);
     if (global.updateTracker.check()) {
-        if (!isSameNativeObject(newTypeParams, oldTypeParams)) {
-            const result = factory.createScriptFunction(
-                newBody,
-                newTypeParams,
-                newParams,
-                newReturnTypeAnnotation,
-                node.hasReceiver,
-                node.flags,
-                node.modifierFlags,
-                newId,
-                newAnnotations,
-                node.getSignaturePointer(),
-                node.getPreferredReturnTypePointer()
-            );
-            result.onUpdate(node);
-            return result;
-        }
         node.setBody(newBody);
         node.setParams(newParams);
+        node.setTypeParams(newTypeParams);
         node.setReturnTypeAnnotation(newReturnTypeAnnotation);
-        if (newId) node.setIdent(newId);
+        node.setIdent(newId);
         node.setAnnotations(newAnnotations);
     }
     return node;
@@ -314,7 +297,6 @@ function visitMethodDefinition(node: MethodDefinition, visitor: Visitor): Method
         node.setOverloads(newOverloads);
         newOverloads.forEach((it): void => {
             it.setBaseOverloadMethod(node);
-            it.parent = node;
         });
     }
     return node;
@@ -538,7 +520,6 @@ function visitIfStatement(node: IfStatement, visitor: Visitor): IfStatement {
             return result;
         }
         node.setTest(newTest);
-        if (newTest) newTest.parent = node;
         node.setAlternate(newAlternate);
     }
     return node;
@@ -828,7 +809,6 @@ function visitETSNewClassInstanceExpression(
             return result;
         }
         node.setArguments(newArguments);
-        newArguments.forEach((it) => (it.parent = node));
     }
     return node;
 }
@@ -865,7 +845,7 @@ function visitForUpdateStatement(node: ForUpdateStatement, visitor: Visitor): Fo
     global.updateTracker.push();
     const newInit = nodeVisitor(node.init, visitor);
     const newTest = nodeVisitor(node.test, visitor);
-    const newUpdate = nodeVisitor(node.update, visitor);
+    const newUpdate = nodeVisitor(node.updateExpression, visitor);
     const newBody = nodeVisitor(node.body, visitor);
     if (global.updateTracker.check()) {
         const result = factory.createForUpdateStatement(newInit, newTest, newUpdate, newBody);
@@ -922,7 +902,6 @@ function visitTSNonNullExpression(node: TSNonNullExpression, visitor: Visitor):
     const newExpr = nodeVisitor(node.expr, visitor);
     if (global.updateTracker.check()) {
         node.setExpr(newExpr);
-        if (newExpr) newExpr.parent = node;
     }
     return node;
 }

package/build/libarkts-copy/src/checkSdk.ts

@@ -31,7 +31,7 @@ export function checkSDK() {
     if (!version) reportErrorAndExit(`version is unknown`);
     const packageJsonOur = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json')).toString());
     const expectedVersion = packageJsonOur.config.panda_sdk_version;
-    if (expectedVersion && expectedVersion != 'next' && version != expectedVersion)
+    if (expectedVersion && expectedVersion !== 'next' && version !== expectedVersion)
         console.log(`WARNING: Panda SDK version "${version}" doesn't match expected "${expectedVersion}"`);
     else console.log(`Using Panda ${version}`);
 }

package/build/libarkts-copy/src/index.ts

@@ -38,10 +38,10 @@ export { GlobalContext } from './arkts-api/peers/Context';
 export * from './arkts-api/peers/ExternalSource';
 export * from './arkts-api/peers/ImportPathManager';
 export * from './arkts-api/peers/Options';
-export * from './arkts-api/peers/DiagnosticKind';
 export { global as arktsGlobal } from './arkts-api/static/global';
 export * from './arkts-api/static/globalUtils';
 export * as arkts from './arkts-api';
 
 export * from './plugin-utils';
 export * from './tracer';
+export * from './memo-node-cache';

package/build/libarkts-copy/src/memo-node-cache.ts

@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { KNativePointer } from "@koalaui/interop";
+import { AstNode, Es2pandaAstNodeType, factory, unpackString } from "./arkts-api";
+import { global } from "./arkts-api/static/global";
+
+// Improve: this should actually belong to plugin contexts, not to libarkts
+
+export interface AstNodeCacheValue {
+    peer: KNativePointer;
+    type: Es2pandaAstNodeType;
+    metadata?: AstNodeCacheValueMetadata;
+}
+
+export interface AstNodeCacheValueMetadata {
+    callName?: string;
+    hasReceiver?: boolean;
+    isSetter?: boolean;
+    isGetter?: boolean;
+    forbidTypeRewrite?: boolean;
+    isWithinTypeParams?: boolean;
+    hasMemoSkip?: boolean;
+    hasMemoIntrinsic?: boolean;
+    hasMemoEntry?: boolean;
+}
+
+export class MemoNodeCache {
+    private _isCollected: boolean = false;
+    private cacheMap: Map<KNativePointer, AstNodeCacheValue>;
+    private static instance: MemoNodeCache;
+    static disableMemoNodeCache = false;
+
+    private constructor() {
+        this.cacheMap = new Map();
+    }
+
+    static getInstance(): MemoNodeCache {
+        if (!this.instance) {
+            this.instance = new MemoNodeCache();
+        }
+        if (this.disableMemoNodeCache) {
+            return this.instance
+        }
+
+        // Please provide the another way to force cache update on when node updates
+        wrapFuncWithNodeCache(this.instance, "updateArrowFunctionExpression")
+        wrapFuncWithNodeCache(this.instance, "updateBreakStatement")
+        wrapFuncWithNodeCache(this.instance, "updateCallExpression")
+        wrapFuncWithNodeCache(this.instance, "updateClassProperty")
+        wrapFuncWithNodeCache(this.instance, "updateETSFunctionType")
+        wrapFuncWithNodeCache(this.instance, "updateETSParameterExpression")
+        wrapFuncWithNodeCache(this.instance, "updateETSUnionType")
+        wrapFuncWithNodeCache(this.instance, "updateIdentifier")
+        wrapFuncWithNodeCache(this.instance, "updateMethodDefinition")
+        wrapFuncWithNodeCache(this.instance, "updateProperty")
+        wrapFuncWithNodeCache(this.instance, "updateReturnStatement")
+        wrapFuncWithNodeCache(this.instance, "updateScriptFunction")
+        wrapFuncWithNodeCache(this.instance, "updateTSTypeAliasDeclaration")
+        wrapFuncWithNodeCache(this.instance, "updateVariableDeclarator")
+
+        return this.instance;
+    }
+
+    collect(node: AstNode, metadata?: AstNodeCacheValueMetadata): void {
+        if (MemoNodeCache.disableMemoNodeCache) {
+            return
+        }
+        const peer = node.peer;
+        const type = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer);
+        let currMetadata: AstNodeCacheValueMetadata | undefined = metadata ?? {};
+        if (this.cacheMap.has(peer)) {
+            const oldMetadata = this.cacheMap.get(peer)!.metadata ?? {};
+            currMetadata = { ...oldMetadata, ...currMetadata };
+        }
+        currMetadata = Object.keys(currMetadata).length === 0 ? undefined : currMetadata;
+        this.cacheMap.set(peer, { peer, type, metadata: currMetadata });
+        this._isCollected = true;
+    }
+
+    refresh(original: AstNode, node: AstNode): void {
+        let metadata: AstNodeCacheValueMetadata | undefined;
+        if (this.has(original)) {
+            metadata = this.get(original)?.metadata;
+            this.cacheMap.delete(original.peer);
+        }
+        this.collect(node, metadata);
+    }
+
+    isCollected(): boolean {
+        return this._isCollected;
+    }
+
+    has(node: AstNode): boolean {
+        return this.cacheMap.has(node.peer);
+    }
+
+    get(node: AstNode): AstNodeCacheValue | undefined {
+        return this.cacheMap.get(node.peer);
+    }
+
+    clear(): void {
+        this.cacheMap.clear();
+        this._isCollected = false;
+    }
+
+    visualize(): void {
+        Array.from(this.cacheMap.values()).forEach(({ peer, type, metadata }) => {
+            const src = global.generatedEs2panda._AstNodeDumpEtsSrcConst(global.context, peer)
+            console.log(
+                `[NODE CACHE] ptr ${peer}, type: ${type}, metadata: ${JSON.stringify(metadata)}, node: `,
+                unpackString(src)
+            );
+        });
+    }
+}
+
+function wrapFuncWithNodeCache(cache: MemoNodeCache, funcName: keyof typeof factory) {
+    if ((funcName+"__orig") in factory) return;
+
+    let orig = factory[funcName] as any;
+    let wrapped = function (this: any, original: AstNode, ...args: any[]) {
+        let newNode = orig.call(this, original, ...args);
+        if (cache.has(original)) {
+            cache.refresh(original, newNode);
+        }
+        return newNode
+    };
+    (factory as any)[funcName] = wrapped as any;
+    (factory as any)[funcName+"__orig"] = orig as any;
+}

package/build/libarkts-copy/src/plugin-utils.ts

@@ -53,7 +53,7 @@ export class DumpingHooks implements RunTransformerHooks {
         }
     }
     onProgramTransformStart(options: CompilationOptions, program: Program) {
-        if (this.dumpAst) {
+        if (this.dumpAst && !program.absoluteName.includes("absolute-sdk-patched")) {
             console.log(`BEFORE ${this.pluginName}:`);
             dumpProgramSrcFormatted(program, true);
         }
@@ -61,7 +61,7 @@ export class DumpingHooks implements RunTransformerHooks {
     }
     onProgramTransformEnd(options: CompilationOptions, program: Program) {
         if (!options.isProgramForCodegeneration) arktsGlobal.profiler.transformDepEnded(this.state, this.pluginName);
-        if (this.dumpAst) {
+        if (this.dumpAst && !program.absoluteName.includes("absolute-sdk-patched")) {
             console.log(`AFTER ${this.pluginName}:`);
             dumpProgramSrcFormatted(program, true);
         }
@@ -73,7 +73,8 @@ export function runTransformerOnProgram(
     options: CompilationOptions,
     transform: ProgramTransformer | undefined,
     pluginContext: PluginContext,
-    hooks: RunTransformerHooks = {}
+    hooks: RunTransformerHooks = {},
+    stableDeps: boolean = false,
 ) {
     arktsGlobal.filePath = program.absoluteName;
 
@@ -82,14 +83,19 @@ export function runTransformerOnProgram(
     // Perform some additional actions before the transformation start
     hooks.onProgramTransformStart?.(options, program);
 
-    // Save currently existing imports in the program
-    const importStorage = new ImportStorage(program, options.state == Es2pandaContextState.ES2PANDA_STATE_PARSED);
+    if (stableDeps) {
+        // Run the plugin itself
+        transform?.(program, options, pluginContext);
+    } else {
+        // Save currently existing imports in the program
+        const importStorage = new ImportStorage(program, options.state === Es2pandaContextState.ES2PANDA_STATE_PARSED);
 
-    // Run the plugin itself
-    transform?.(program, options, pluginContext);
+        // Run the plugin itself
+        transform?.(program, options, pluginContext);
 
-    // Update internal import information based on import modification by plugin
-    importStorage.update();
+        // Update internal import information based on import modification by plugin
+        importStorage.update();
+    }
 
     // Perform some additional actions after the transformation end
     hooks.onProgramTransformEnd?.(options, program);
@@ -102,10 +108,11 @@ export function runTransformer(
     state: Es2pandaContextState,
     transform: ProgramTransformer | undefined,
     pluginContext: PluginContext,
-    hooks: RunTransformerHooks = {}
+    hooks: RunTransformerHooks = {},
+    stableDeps: boolean = false,
 ) {
     // Program provider used to provide programs to transformer dynamically relative to inserted imports
-    const provider = new ProgramProvider(prog);
+    const provider = new ProgramProvider(prog, stableDeps);
 
     // The first program provided by program provider is the main program
     let currentProgram = provider.next();
@@ -118,7 +125,7 @@ export function runTransformer(
             state,
         };
 
-        runTransformerOnProgram(currentProgram, options, transform, pluginContext, hooks);
+        runTransformerOnProgram(currentProgram, options, transform, pluginContext, hooks, stableDeps);
 
         // The first program is always the main program
         isMainProgram = false;

package/build/libarkts-copy/src/reexport-for-generated.ts

@@ -14,6 +14,8 @@
  */
 export { KNativePointer } from '@koalaui/interop';
 export { AstNode } from './arkts-api/peers/AstNode';
+export { Config } from './arkts-api/peers/Config';
+export { Context, GlobalContext } from './arkts-api/peers/Context';
 export { ArktsObject, isSameNativeObject } from './arkts-api/peers/ArktsObject';
 export { NodeCache } from './arkts-api/node-cache';
 export {