@azure-net/cli 6.0.0-next.2 → 6.0.0-next.3

package/README.md

@@ -60,7 +60,7 @@ classes plus accessors. The migrator preserves lexical state through a private
 state object and rewrites named consumer imports/re-exports to the accessor,
 retaining their local aliases. Async-helper factories are replaced by direct
 function references, preserving explicit custom error types. Unsupported custom
-injections and dynamic consumer imports are listed in the migration report for
+unresolved injections and dynamic consumer imports are listed in the migration report for
 manual review. Original files remain in the migration snapshot.
 
 `scoped` means request-cached on the server and new-per-call in the browser, not
@@ -187,3 +187,15 @@ it writes `state.currLocale` and dictionary snapshots automatically. Call
 in useClient. Templates include these integration hints. In components use
 `t(key)` and `manager.locale`, not `$t` / `$locale`. No separate translations
 package, exportState or restoreState is required.
+
+### Presenter and translation API migration
+
+- Presenter factory imports are resolved through local modules and barrels, including aliases.
+- Statically declared custom injections (for example notification/modal accessors) become constructor arguments. The factory module retains a plain exported dependency object, not a createPresenterFactory call.
+- Async helpers are imported from @azure-net/kit/delivery; factory-specific error types are preserved with type-only specialization. Custom overrides are injected rather than replaced with kit helpers.
+- Closures, mutable private variables and detached callbacks are retained behind class accessors. Registration uses RegisterProvider with scoped lifecycle. Consumers and re-exports are updated.
+- Opaque spreads, getter-based injection definitions, local per-presenter injection overrides, explicit factory result types and unsupported return shapes require manual review. No application configuration is executed to infer their meaning.
+- A single identifiable translation manager is connected to useTranslations before the existing bootstrap chain. Known zero-argument legacy preload/initialization calls become resolved promises so existing helper consumers remain compatible. Custom locale resolvers and ambiguous managers are not rewritten automatically.
+- Existing bootstrap dependencies/Container usage, stores and other removed kit APIs are not converted into new application-specific state architecture by this migration. Check the resulting project and migration report before publishing.
+
+Run azure-net migrate --dry-run first. Migration also works on presenters left behind in an already migrated Contexts/Presentation/Platform structure.

package/dist/src/migrate/presenterFactories.d.ts

@@ -0,0 +1,9 @@
+export interface FactoryDefinition {
+    name: string;
+    exportName: string;
+    keys: Set<string>;
+    helpers: Set<string>;
+}
+/** Only evaluate syntax. Never import or execute the application's factory/configuration. */
+export declare function inspectFactories(input: string, file: string): FactoryDefinition[];
+export declare function replaceFactory(input: string, file: string, definition: FactoryDefinition, keepLegacy: boolean): string;

package/dist/src/migrate/presenters.d.ts

@@ -1,6 +1,12 @@
 export declare function migrateAsyncHelpers(input: string, file: string): string;
-/** Upgrade only recognized factories; arbitrary injected dependencies require a human decision. */
-export declare function migratePresenterSource(input: string, file: string, factories: Set<string>): {
+export interface PresenterDependencies {
+    source: string;
+    exportName: string;
+    keys: Set<string>;
+    helpers: Set<string>;
+}
+/** Preserve lexical behavior while moving instance creation and dependencies to RegisterProvider. */
+export declare function migratePresenterSource(input: string, file: string, factories: Set<string>, dependencies?: Map<string, PresenterDependencies>): {
     content: string;
     converted: Map<string, string>;
     issues: string[];

package/dist/src/migrate/translations.d.ts

@@ -0,0 +1,8 @@
+/** A conservative migration of known translation wiring, never a project-wide textual replacement. */
+export declare function migrateTranslationsSources(sources: Map<string, string>, resolve: (from: string, specifier: string) => string | undefined): {
+    updates: Map<string, string>;
+    issues: {
+        file: string;
+        reason: string;
+    }[];
+};

package/package.json

@@ -1,49 +1,47 @@
 {
-	"name": "@azure-net/cli",
-	"version": "6.0.0-next.2",
-	"type": "module",
-	"bin": {
-		"azure-net": "bin/azure-net.js"
-	},
-	"license": "MIT",
-	"author": "Pixel1917",
-	"publishConfig": {
-		"access": "public",
-		"registry": "https://registry.npmjs.org/"
-	},
-	"peerDependencies": {
-		"@azure-net/kit": ">=6.0.0-next.1"
-	},
-	"dependencies": {
-		"commander": "^11",
-		"prompts": "^2",
-		"typescript": "^5",
-		"prettier": "^3.6.2"
-	},
-	"devDependencies": {
-		"@eslint/js": "^9.31.0",
-		"@types/node": "^24.0.3",
-		"@types/prompts": "^2.4.9",
-		"env-cmd": "^11.0.0",
-		"eslint": "^9.31.0",
-		"typescript-eslint": "^8.36.0"
-	},
-	"scripts": {
-		"build": "node scripts/clean-build.mjs && tsc -p tsconfig.json && node scripts/sync-build.mjs",
-		"typecheck": "tsc --noEmit -p tsconfig.json",
-		"lint": "eslint \"bin/**/*.ts\" \"src/**/*.ts\"",
-		"format": "prettier --write .",
-		"test": "pnpm build && node --test tests/*.test.mjs",
-		"prepack": "pnpm build"
-	},
-	"packageManager": "pnpm@9.13.2+sha512.88c9c3864450350e65a33587ab801acf946d7c814ed1134da4a924f6df5a2120fd36b46aab68f7cd1d413149112d53c7db3a4136624cfd00ff1846a0c6cef48a",
-	"files": [
-		"bin/*.js",
-		"src/**/*.js",
-		"dist/**/*.d.ts",
-		"README.md"
-	],
-	"engines": {
-		"node": ">=22.15.0"
-	}
-}
+  "name": "@azure-net/cli",
+  "version": "6.0.0-next.3",
+  "type": "module",
+  "bin": {
+    "azure-net": "bin/azure-net.js"
+  },
+  "license": "MIT",
+  "author": "Pixel1917",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "peerDependencies": {
+    "@azure-net/kit": ">=6.0.0-next.1"
+  },
+  "dependencies": {
+    "commander": "^11",
+    "prompts": "^2",
+    "typescript": "^5",
+    "prettier": "^3.6.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.31.0",
+    "@types/node": "^24.0.3",
+    "@types/prompts": "^2.4.9",
+    "env-cmd": "^11.0.0",
+    "eslint": "^9.31.0",
+    "typescript-eslint": "^8.36.0"
+  },
+  "files": [
+    "bin/*.js",
+    "src/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22.15.0"
+  },
+  "scripts": {
+    "build": "node scripts/clean-build.mjs && tsc -p tsconfig.json && node scripts/sync-build.mjs",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "lint": "eslint \"bin/**/*.ts\" \"src/**/*.ts\"",
+    "format": "prettier --write .",
+    "test": "pnpm build && node --test tests/*.test.mjs"
+  }
+}

package/src/migrate/migrate.js

@@ -1,3 +1,4 @@
+import { migrateTranslationsSources } from './translations.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
@@ -8,6 +9,7 @@ import { VITE_CONFIGS } from '../utils/viteConfig.js';
 import { mergePackageImports, resolvePackageImport } from '../utils/packageImports.js';
 import { flattenConfigLiterals } from '../utils/flattenConfig.js';
 import { parseSource } from '../checks/architecture.js';
+import { inspectFactories, replaceFactory } from './presenterFactories.js';
 import { migrateAsyncHelpers, migratePresenterSource } from './presenters.js';
 const slash = (s) => s.split(path.sep).join('/');
 const textFile = /\.(?:[cm]?[jt]sx?|svelte|css|scss|sass|less|json|html|svg)$/;
@@ -289,9 +291,13 @@ export async function planMigration(root = process.cwd()) {
     const presenterNames = new Map();
     const upgradedSources = new Map();
     const factorySymbols = new Map();
+    const factoryDefinitions = new Map();
+    const legacyFactories = new Set();
+    const consumedFactories = new Set();
     for (const [file, bytes] of originals) {
         if (!/\.[jt]s$/.test(file))
             continue;
+        factoryDefinitions.set(file, inspectFactories(bytes.toString(), file));
         const source = parseSource(bytes.toString(), file);
         const creators = new Set();
         for (const statement of source.statements) {
@@ -329,6 +335,8 @@ export async function planMigration(root = process.cwd()) {
             continue;
         const source = parseSource(bytes.toString(), file);
         const factories = new Set();
+        const dependencies = new Map();
+        const definitions = new Map();
         for (const statement of source.statements) {
             if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
                 continue;
@@ -344,11 +352,34 @@ export async function planMigration(root = process.cwd()) {
                     ['@azure-net/kit/delivery', '@azure-net/edges'].includes(statement.moduleSpecifier.text)) ||
                     (symbol && factorySymbols.get(symbol.file)?.has(symbol.name)))
                     factories.add(binding.name.text);
+                if (symbol) {
+                    const definition = factoryDefinitions.get(symbol.file)?.find((value) => value.name === symbol.name);
+                    if (definition) {
+                        let module = slash(path.relative(path.dirname(file), symbol.file)).replace(/\.[jt]s$/, '');
+                        if (!module.startsWith('.'))
+                            module = './' + module;
+                        dependencies.set(binding.name.text, { ...definition, source: module });
+                        definitions.set(binding.name.text, definition);
+                    }
+                }
             }
         }
         const result = file.endsWith('.svelte')
             ? { content: bytes.toString(), converted: new Map(), issues: [] }
-            : migratePresenterSource(bytes.toString(), file, factories);
+            : migratePresenterSource(bytes.toString(), file, factories, dependencies);
+        for (const [local, definition] of definitions) {
+            if (result.converted.size)
+                consumedFactories.add(definition);
+            const remaining = ts.createSourceFile(file, result.content, ts.ScriptTarget.Latest, true);
+            const visit = (node) => {
+                if (ts.isImportDeclaration(node))
+                    return;
+                if (ts.isIdentifier(node) && node.text === local)
+                    legacyFactories.add(definition);
+                ts.forEachChild(node, visit);
+            };
+            visit(remaining);
+        }
         if (result.converted.size)
             presenterNames.set(file, result.converted);
         for (const reason of result.issues)
@@ -363,6 +394,86 @@ export async function planMigration(root = process.cwd()) {
         if (upgraded !== bytes.toString())
             upgradedSources.set(file, upgraded);
     }
+    for (const [file, definitions] of factoryDefinitions) {
+        let content = originals.get(file).toString();
+        let changed = false;
+        for (const definition of definitions) {
+            if (!consumedFactories.has(definition))
+                continue;
+            const keepLegacy = legacyFactories.has(definition);
+            content = replaceFactory(content, file, definition, keepLegacy);
+            changed = true;
+            if (!keepLegacy) {
+                const names = presenterNames.get(file) ?? new Map();
+                names.set(definition.name, definition.exportName);
+                presenterNames.set(file, names);
+            }
+            else
+                issue(file, 'Some factory consumers could not be migrated; legacy factory retained alongside explicit dependencies.');
+        }
+        if (changed) {
+            try {
+                content = migrateAsyncHelpers(content, file);
+            }
+            catch (error) {
+                issue(file, String(error));
+            }
+            upgradedSources.set(file, content);
+        }
+    }
+    const translationMigration = migrateTranslationsSources(new Map([...originals]
+        .filter(([file]) => file.startsWith(path.join(root, 'src') + path.sep))
+        .map(([file, bytes]) => [file, upgradedSources.get(file) ?? bytes.toString()])), resolve);
+    for (const [file, content] of translationMigration.updates)
+        upgradedSources.set(file, content);
+    for (const problem of translationMigration.issues)
+        issue(problem.file, problem.reason);
+    for (const [file, bytes] of originals) {
+        if (!/\.[jt]s$/.test(file) || isBackup(mapping.get(file) ?? file))
+            continue;
+        const source = parseSource(upgradedSources.get(file) ?? bytes.toString(), file);
+        const removed = new Set(['createPresenterFactory', 'createPresenter', 'createStoreFactory', 'createStore', 'createAsyncHelpers']);
+        const apps = new Set();
+        for (const statement of source.statements) {
+            if (!ts.isImportDeclaration(statement) ||
+                !ts.isStringLiteral(statement.moduleSpecifier) ||
+                !['@azure-net/kit', '@azure-net/kit/delivery'].includes(statement.moduleSpecifier.text))
+                continue;
+            const bindings = statement.importClause?.namedBindings;
+            if (!bindings || !ts.isNamedImports(bindings))
+                continue;
+            for (const binding of bindings.elements) {
+                const name = (binding.propertyName ?? binding.name).text;
+                if (removed.has(name))
+                    issue(file, 'Removed kit API ' + name + ' remains; manual migration is required before build.');
+                if (name === 'createApp')
+                    apps.add(binding.name.text);
+            }
+        }
+        const inspect = (node) => {
+            if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && apps.has(node.expression.text)) {
+                const callback = node.arguments[0];
+                if (callback && (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback))) {
+                    const parameter = callback.parameters[0]?.name;
+                    const check = (child) => {
+                        if (ts.isCallExpression(child) &&
+                            ts.isPropertyAccessExpression(child.expression) &&
+                            child.expression.name.text === 'dependencies') {
+                            let base = child.expression.expression;
+                            while (ts.isCallExpression(base) && ts.isPropertyAccessExpression(base.expression))
+                                base = base.expression.expression;
+                            if (parameter && ts.isIdentifier(parameter) && ts.isIdentifier(base) && base.text === parameter.text)
+                                issue(file, 'createApp.dependencies/Container was removed. Move these bindings to a DiContainer; consumer changes require manual review.');
+                        }
+                        ts.forEachChild(child, check);
+                    };
+                    check(callback.body);
+                }
+            }
+            ts.forEachChild(node, inspect);
+        };
+        inspect(source);
+    }
     const providers = new Map();
     for (const [file, bytes] of originals)
         if (/Provider\.[jt]s$/.test(file) && mapping.has(file)) {
@@ -631,7 +742,7 @@ export async function planMigration(root = process.cwd()) {
                         const declared = symbol?.file ?? target;
                         const to = mapping.get(declared) ?? declared;
                         const isProvider = converted.has(name) && providers.get(name)?.file === declared;
-                        const spec = isProvider ? '#platform/Foundation/DI' : isBackup(to) ? undefined : specifier(to, destination);
+                        const spec = isProvider ? '#platform/Foundation/DI/ApplicationProvider' : isBackup(to) ? undefined : specifier(to, destination);
                         if (!spec) {
                             issue(destination, `Unresolved imported symbol ${name} from ${node.moduleSpecifier.text}`);
                             continue;
@@ -736,6 +847,8 @@ export async function planMigration(root = process.cwd()) {
         if (!file.startsWith(path.join(root, 'src') + path.sep))
             continue;
         const to = mapping.get(file) ?? file;
+        if (!oldRoots.size && !upgradedSources.size)
+            continue;
         const output = isBackup(to) || !textFile.test(file) ? bytes : Buffer.from(rewrite(file, to, upgradedSources.get(file) ?? bytes.toString()));
         if (writes.has(to) && path.basename(to) === 'index.ts') {
             const barrel = ts.createSourceFile(to, writes.get(to).toString() + '\n' + output.toString(), ts.ScriptTarget.Latest, true);

package/src/migrate/presenterFactories.js

@@ -0,0 +1,189 @@
+import ts from 'typescript';
+const kitModules = new Set(['@azure-net/kit/delivery', '@azure-net/edges']);
+const helperNames = new Set(['createAsyncAction', 'createAsyncResource']);
+const unwrap = (node) => ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertionExpression(node) || ts.isSatisfiesExpression(node)
+    ? unwrap(node.expression)
+    : node;
+/** Only evaluate syntax. Never import or execute the application's factory/configuration. */
+export function inspectFactories(input, file) {
+    const source = ts.createSourceFile(file, input, ts.ScriptTarget.Latest, true);
+    const creators = new Set();
+    const helperFactories = new Set();
+    const helpers = new Map();
+    const occupied = new Set();
+    const visit = (node) => {
+        if (ts.isIdentifier(node))
+            occupied.add(node.text);
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    for (const statement of source.statements) {
+        if (!ts.isImportDeclaration(statement) ||
+            !ts.isStringLiteral(statement.moduleSpecifier) ||
+            !kitModules.has(statement.moduleSpecifier.text) ||
+            statement.importClause?.isTypeOnly)
+            continue;
+        const bindings = statement.importClause?.namedBindings;
+        if (!bindings || !ts.isNamedImports(bindings))
+            continue;
+        for (const binding of bindings.elements) {
+            if (binding.isTypeOnly)
+                continue;
+            const name = (binding.propertyName ?? binding.name).text;
+            if (name === 'createPresenterFactory')
+                creators.add(binding.name.text);
+            if (name === 'createAsyncHelpers')
+                helperFactories.add(binding.name.text);
+            if (helperNames.has(name))
+                helpers.set(binding.name.text, name);
+        }
+    }
+    for (const statement of source.statements) {
+        if (!ts.isVariableStatement(statement))
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            const init = declaration.initializer && unwrap(declaration.initializer);
+            if (!init || !ts.isObjectBindingPattern(declaration.name))
+                continue;
+            const available = new Set();
+            if (ts.isCallExpression(init) &&
+                ts.isIdentifier(init.expression) &&
+                helperFactories.has(init.expression.text) &&
+                !init.arguments.length) {
+                for (const helper of helperNames)
+                    available.add(helper);
+            }
+            else if (ts.isObjectLiteralExpression(init)) {
+                for (const property of init.properties) {
+                    if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name))
+                        continue;
+                    const value = unwrap(property.initializer);
+                    if (ts.isIdentifier(value) && helpers.get(value.text) === property.name.text)
+                        available.add(property.name.text);
+                }
+            }
+            for (const binding of declaration.name.elements) {
+                const key = binding.propertyName ?? binding.name;
+                if (ts.isIdentifier(key) &&
+                    ts.isIdentifier(binding.name) &&
+                    available.has(key.text) &&
+                    !binding.initializer &&
+                    !binding.dotDotDotToken)
+                    helpers.set(binding.name.text, key.text);
+            }
+        }
+    }
+    const found = [];
+    for (const statement of source.statements) {
+        if (!ts.isVariableStatement(statement) || statement.declarationList.declarations.length !== 1)
+            continue;
+        const declaration = statement.declarationList.declarations[0];
+        const init = declaration.initializer;
+        if (!ts.isIdentifier(declaration.name) ||
+            !init ||
+            !ts.isCallExpression(init) ||
+            !ts.isIdentifier(init.expression) ||
+            !creators.has(init.expression.text) ||
+            init.arguments.length !== 1)
+            continue;
+        const config = init.arguments[0];
+        if (!ts.isObjectLiteralExpression(config))
+            continue;
+        const keys = new Set();
+        const directHelpers = new Set();
+        let safe = true;
+        for (const property of config.properties) {
+            if (ts.isSpreadAssignment(property)) {
+                const call = property.expression;
+                if (!ts.isCallExpression(call) ||
+                    !ts.isIdentifier(call.expression) ||
+                    !helperFactories.has(call.expression.text) ||
+                    call.arguments.length) {
+                    safe = false;
+                    break;
+                }
+                for (const helper of helperNames) {
+                    keys.add(helper);
+                    directHelpers.add(helper);
+                }
+                continue;
+            }
+            if ((!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) ||
+                !property.name ||
+                (!ts.isIdentifier(property.name) && !ts.isStringLiteral(property.name))) {
+                safe = false;
+                break;
+            }
+            const key = property.name.text;
+            if (keys.has(key)) {
+                safe = false;
+                break;
+            }
+            keys.add(key);
+            const value = ts.isShorthandPropertyAssignment(property) ? property.name : property.initializer;
+            if (ts.isIdentifier(value) && helpers.get(value.text) === key)
+                directHelpers.add(key);
+        }
+        if (!safe)
+            continue;
+        let exportName = declaration.name.text + 'Dependencies';
+        while (occupied.has(exportName))
+            exportName += '_';
+        occupied.add(exportName);
+        found.push({ name: declaration.name.text, exportName, keys, helpers: directHelpers });
+    }
+    return found;
+}
+export function replaceFactory(input, file, definition, keepLegacy) {
+    const source = ts.createSourceFile(file, input, ts.ScriptTarget.Latest, true);
+    let creator;
+    for (const statement of source.statements) {
+        if (!ts.isVariableStatement(statement) || statement.declarationList.declarations.length !== 1)
+            continue;
+        const declaration = statement.declarationList.declarations[0];
+        if (!ts.isIdentifier(declaration.name) ||
+            declaration.name.text !== definition.name ||
+            !declaration.initializer ||
+            !ts.isCallExpression(declaration.initializer))
+            continue;
+        const call = declaration.initializer;
+        creator = call.expression.getText(source);
+        const config = call.arguments[0].getText(source);
+        const replacement = `export const ${definition.exportName} = ${config};\n` +
+            (keepLegacy ? `export const ${definition.name} = ${creator}(${definition.exportName});` : '');
+        input = input.slice(0, statement.getStart(source)) + replacement + input.slice(statement.end);
+        break;
+    }
+    if (!creator || keepLegacy)
+        return input;
+    const parsed = ts.createSourceFile(file, input, ts.ScriptTarget.Latest, true);
+    let used = false;
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node))
+            return;
+        if (ts.isIdentifier(node) && node.text === creator)
+            used = true;
+        ts.forEachChild(node, visit);
+    };
+    visit(parsed);
+    if (used)
+        return input;
+    for (const statement of [...parsed.statements].reverse()) {
+        if (!ts.isImportDeclaration(statement) ||
+            !statement.importClause?.namedBindings ||
+            !ts.isNamedImports(statement.importClause.namedBindings))
+            continue;
+        const bindings = statement.importClause.namedBindings;
+        const kept = bindings.elements.filter((binding) => binding.name.text !== creator);
+        if (kept.length === bindings.elements.length)
+            continue;
+        if (!kept.length && !statement.importClause.name)
+            input = input.slice(0, statement.getStart(parsed)) + input.slice(statement.end);
+        else
+            input =
+                input.slice(0, bindings.getStart(parsed)) +
+                    `{ ${kept.map((binding) => binding.getText(parsed)).join(', ')} }` +
+                    input.slice(bindings.end);
+    }
+    return input;
+}

package/src/migrate/presenters.js

@@ -71,10 +71,19 @@ export function migrateAsyncHelpers(input, file) {
     const visit = (node) => {
         if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && factories.has(node.expression.text) && !node.arguments.length) {
             const errorType = node.typeArguments?.[0]?.getText(source);
+            let keys = [...helperNames];
+            const parent = node.parent;
+            if (ts.isVariableDeclaration(parent) &&
+                ts.isObjectBindingPattern(parent.name) &&
+                !parent.name.elements.some((b) => b.dotDotDotToken)) {
+                keys = parent.name.elements.map((b) => (b.propertyName ?? b.name).getText(source));
+                if (keys.some((key) => !helperNames.has(key)))
+                    throw new Error('Removed async helper members require manual migration');
+            }
             edits.push({
                 start: node.getStart(source),
                 end: node.end,
-                text: `({ createAsyncAction: ${specialize(action, errorType)}, createAsyncResource: ${specialize(resource, errorType)} })`
+                text: `({ ${keys.map((key) => `${key}: ${specialize(key === 'createAsyncAction' ? action : resource, errorType)}`).join(', ')} })`
             });
             return;
         }
@@ -83,8 +92,8 @@ export function migrateAsyncHelpers(input, file) {
     visit(source);
     return apply(input, edits);
 }
-/** Upgrade only recognized factories; arbitrary injected dependencies require a human decision. */
-export function migratePresenterSource(input, file, factories) {
+/** Preserve lexical behavior while moving instance creation and dependencies to RegisterProvider. */
+export function migratePresenterSource(input, file, factories, dependencies = new Map()) {
     const source = ts.createSourceFile(file, input, ts.ScriptTarget.Latest, true);
     const edits = [];
     const converted = new Map();
@@ -92,6 +101,21 @@ export function migratePresenterSource(input, file, factories) {
     const imports = new Set();
     const removedFactories = new Set();
     const existingImports = new Set();
+    const dependencyImports = [];
+    const occupied = new Set();
+    const collectNames = (node) => {
+        if (ts.isIdentifier(node))
+            occupied.add(node.text);
+        ts.forEachChild(node, collectNames);
+    };
+    collectNames(source);
+    const unique = (base) => {
+        let value = base;
+        while (occupied.has(value))
+            value += '_';
+        occupied.add(value);
+        return value;
+    };
     for (const statement of source.statements) {
         if (!ts.isImportDeclaration(statement) ||
             !ts.isStringLiteral(statement.moduleSpecifier) ||
@@ -105,6 +129,8 @@ export function migratePresenterSource(input, file, factories) {
                     existingImports.add(entry.propertyName ? `${entry.propertyName.text} as ${entry.name.text}` : entry.name.text);
             }
     }
+    const existingRegistration = [...existingImports].find((name) => name === 'RegisterProvider' || name.startsWith('RegisterProvider as '));
+    const registrationName = existingRegistration ? existingRegistration.split(' as ').at(-1) : unique('RegisterProvider');
     for (const statement of source.statements) {
         if (!ts.isVariableStatement(statement) || statement.declarationList.declarations.length !== 1)
             continue;
@@ -118,6 +144,8 @@ export function migratePresenterSource(input, file, factories) {
             continue;
         const name = declaration.name.text;
         try {
+            if (call.typeArguments?.length || declaration.type)
+                throw new Error('Explicit factory result types require manual review');
             const callback = call.arguments.find((arg) => ts.isArrowFunction(arg) || ts.isFunctionExpression(arg));
             if (!callback ||
                 (!ts.isArrowFunction(callback) && !ts.isFunctionExpression(callback)) ||
@@ -125,18 +153,53 @@ export function migratePresenterSource(input, file, factories) {
                 callback.typeParameters ||
                 callback.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword))
                 throw new Error('Expected a synchronous block factory');
-            if (call.arguments.length !== 2 || !ts.isStringLiteral(call.arguments[0]))
+            if (!((call.arguments.length === 2 && ts.isStringLiteral(call.arguments[0])) ||
+                (call.arguments.length === 1 && call.arguments[0] === callback)))
                 throw new Error('Custom factory arguments need manual review');
             const requestedImports = new Set();
+            const dependency = dependencies.get(call.expression.text);
+            const dependencyAlias = unique(name + 'Dependencies');
+            const extraParameters = [];
+            const extraArguments = [];
+            const extraRegistrations = [];
+            const helperSetup = [];
+            const javascript = file.endsWith('.js');
+            let needsDependencyImport = false;
+            let runtimeDependencyImport = false;
             if (callback.parameters.length) {
                 const param = callback.parameters[0];
                 if (callback.parameters.length !== 1 || !ts.isObjectBindingPattern(param.name) || param.initializer)
                     throw new Error('Unsupported injected dependencies');
                 for (const binding of param.name.elements) {
                     const original = (binding.propertyName ?? binding.name).getText(source);
-                    if (!helperNames.has(original) || !ts.isIdentifier(binding.name) || binding.initializer || binding.dotDotDotToken)
-                        throw new Error(`Injected dependency ${original} requires manual conversion`);
-                    requestedImports.add(original === binding.name.text ? original : `${original} as ${binding.name.text}`);
+                    if (!ts.isIdentifier(binding.name) || binding.initializer || binding.dotDotDotToken)
+                        throw new Error('Nested, default or rest injected bindings need manual conversion');
+                    if (dependency) {
+                        if (!dependency.keys.has(original) && helperNames.has(original)) {
+                            requestedImports.add(original === binding.name.text ? original : `${original} as ${binding.name.text}`);
+                            continue;
+                        }
+                        if (!dependency.keys.has(original))
+                            throw new Error(`Injected dependency ${original} is not statically known in its factory`);
+                        if (helperNames.has(original) && dependency.helpers.has(original)) {
+                            const helperAlias = unique('kit' + original[0].toUpperCase() + original.slice(1));
+                            requestedImports.add(`${original} as ${helperAlias}`);
+                            helperSetup.push(`const ${binding.name.text}${javascript ? '' : ': typeof ' + dependencyAlias + '[' + JSON.stringify(original) + ']'} = ${helperAlias};`);
+                            if (!javascript)
+                                needsDependencyImport = true;
+                        }
+                        else {
+                            needsDependencyImport = runtimeDependencyImport = true;
+                            extraParameters.push(`${binding.name.text}: typeof ${dependencyAlias}[${JSON.stringify(original)}]`);
+                            extraArguments.push(binding.name.text);
+                            extraRegistrations.push(`${dependencyAlias}[${JSON.stringify(original)}]`);
+                        }
+                    }
+                    else {
+                        if (!helperNames.has(original))
+                            throw new Error(`Injected dependency ${original} requires manual conversion`);
+                        requestedImports.add(original === binding.name.text ? original : `${original} as ${binding.name.text}`);
+                    }
                 }
             }
             const statements = [...callback.body.statements];
@@ -152,6 +215,16 @@ export function migratePresenterSource(input, file, factories) {
             const result = statements.at(-1);
             if (!result || !ts.isReturnStatement(result) || !result.expression || !ts.isObjectLiteralExpression(result.expression))
                 throw new Error('Expected a final object-literal return');
+            const validateFlow = (node) => {
+                if (ts.isFunctionLike(node) || ts.isClassLike(node))
+                    return;
+                if (ts.isReturnStatement(node) && node !== result)
+                    throw new Error('Conditional early returns require manual conversion');
+                if (ts.isIdentifier(node) && node.text === 'arguments')
+                    throw new Error('Factory arguments binding requires manual conversion');
+                ts.forEachChild(node, validateFlow);
+            };
+            validateFlow(callback.body);
             const keys = result.expression.properties.map((prop) => {
                 if (!prop.name || !ts.isIdentifier(prop.name))
                     throw new Error('Spread/computed return keys require manual conversion');
@@ -161,8 +234,9 @@ export function migratePresenterSource(input, file, factories) {
             });
             if (new Set(keys).size !== keys.length)
                 throw new Error('Duplicate return keys');
-            const parameters = [];
-            const argumentsList = [];
+            const parameters = [...extraParameters];
+            const argumentsList = [...extraArguments];
+            const registrationArguments = [...extraRegistrations];
             const registrations = [];
             const body = statements.filter((stmt) => {
                 if (!ts.isVariableStatement(stmt) || stmt.declarationList.declarations.length !== 1)
@@ -183,6 +257,7 @@ export function migratePresenterSource(input, file, factories) {
                     const key = (entry.propertyName ?? entry.name).getText(source).replace(/^['"]|['"]$/g, '');
                     parameters.push(`${entry.name.text}: ReturnType<typeof ${value.expression.text}>[${JSON.stringify(key)}]`);
                     argumentsList.push(entry.name.text);
+                    registrationArguments.push(entry.name.text);
                 }
                 registrations.push(stmt.getText(source));
                 return false;
@@ -191,7 +266,6 @@ export function migratePresenterSource(input, file, factories) {
             const setup = `create${name}State`;
             if (new RegExp(`\\b(?:use${name}|${setup})\\b`).test(input))
                 throw new Error('Generated declaration name already exists');
-            const javascript = file.endsWith('.js');
             const parameterList = (javascript ? argumentsList : parameters).join(', ');
             const members = result.expression.properties.map((property, index) => {
                 const key = keys[index];
@@ -200,11 +274,13 @@ export function migratePresenterSource(input, file, factories) {
                         ? ''
                         : `\nset ${key}(value${javascript ? '' : `: ReturnType<typeof ${setup}>[${JSON.stringify(key)}]`}) { this.#state.${key} = value; }`));
             });
-            const text = `function ${setup}(${parameterList})${callback.type ? ': ' + callback.type.getText(source) : ''} {\n${body.map((stmt) => stmt.getText(source)).join('\n')}\n}\n\nexport class ${name} {\n#state${javascript ? '' : `: ReturnType<typeof ${setup}>`};\nconstructor(${parameterList}) { this.#state = ${setup}(${argumentsList.join(', ')}); }\n${members.join('\n')}\n}\n\nexport const use${name} = RegisterProvider(() => {\n${registrations.join('\n')}\nreturn new ${name}(${argumentsList.join(', ')});\n}, 'scoped');`;
+            const text = `function ${setup}(${parameterList})${callback.type ? ': ' + callback.type.getText(source) : ''} {\n${helperSetup.join('\n')}\n${body.map((stmt) => stmt.getText(source)).join('\n')}\n}\n\nexport class ${name} {\n#state${javascript ? '' : `: ReturnType<typeof ${setup}>`};\nconstructor(${parameterList}) { this.#state = ${setup}(${argumentsList.join(', ')}); }\n${members.join('\n')}\n}\n\nexport const use${name} = ${registrationName}(() => {\n${registrations.join('\n')}\nreturn new ${name}(${registrationArguments.join(', ')});\n}, 'scoped');`;
+            if (needsDependencyImport && dependency)
+                dependencyImports.push(`import ${runtimeDependencyImport ? '' : 'type '}{ ${dependency.exportName} as ${dependencyAlias} } from ${JSON.stringify(dependency.source)};`);
             edits.push({ start: statement.getStart(source), end: statement.end, text });
             converted.set(name, `use${name}`);
             removedFactories.add(call.expression.text);
-            imports.add('RegisterProvider');
+            imports.add(registrationName === 'RegisterProvider' ? 'RegisterProvider' : `RegisterProvider as ${registrationName}`);
             for (const helper of requestedImports)
                 imports.add(helper);
         }
@@ -249,12 +325,44 @@ export function migratePresenterSource(input, file, factories) {
         }
         const neededImports = [...imports].filter((name) => !existingImports.has(name));
         output =
-            (neededImports.length ? `import { ${neededImports.join(', ')} } from '@azure-net/kit/delivery';\n` : '') + apply(output, importEdits);
+            dependencyImports.join('\n') +
+                '\n' +
+                (neededImports.length ? `import { ${neededImports.join(', ')} } from '@azure-net/kit/delivery';\n` : '') +
+                apply(output, importEdits);
         const updated = ts.createSourceFile(file, output, ts.ScriptTarget.Latest, true);
+        // Bind only this in-memory module: distinguish lexical shadows without loading dependencies.
+        const options = { noLib: true, noResolve: true, target: ts.ScriptTarget.ES2022 };
+        const host = ts.createCompilerHost(options);
+        host.getSourceFile = (name) => (name === file ? updated : undefined);
+        host.fileExists = (name) => name === file;
+        host.readFile = (name) => (name === file ? output : undefined);
+        const checker = ts.createProgram([file], options, host).getTypeChecker();
+        const symbols = new Map();
+        for (const statement of updated.statements) {
+            if (!ts.isClassDeclaration(statement) || !statement.name || !converted.has(statement.name.text))
+                continue;
+            const symbol = checker.getSymbolAtLocation(statement.name);
+            if (symbol)
+                symbols.set(symbol, converted.get(statement.name.text));
+        }
         const references = [];
         const visit = (node) => {
-            if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && converted.has(node.expression.text)) {
-                references.push({ start: node.expression.getStart(updated), end: node.expression.end, text: converted.get(node.expression.text) });
+            if (ts.isShorthandPropertyAssignment(node)) {
+                const symbol = checker.getShorthandAssignmentValueSymbol(node);
+                const name = symbol && symbols.get(symbol);
+                if (name) {
+                    references.push({ start: node.getStart(updated), end: node.end, text: `${node.name.text}: ${name}` });
+                    return;
+                }
+            }
+            if (ts.isIdentifier(node) && converted.has(node.text)) {
+                const parent = node.parent;
+                const declaration = ts.isClassDeclaration(parent) && parent.name === node;
+                const construction = ts.isNewExpression(parent) && parent.expression === node;
+                const symbol = checker.getSymbolAtLocation(node);
+                const name = symbol && symbols.get(symbol);
+                if (name && !declaration && !construction)
+                    references.push({ start: node.getStart(updated), end: node.end, text: name });
             }
             ts.forEachChild(node, visit);
         };

package/src/migrate/translations.js

@@ -0,0 +1,213 @@
+import path from 'node:path';
+import ts from 'typescript';
+const patch = (input, edits) => {
+    for (const e of edits.sort((a, b) => b.start - a.start))
+        input = input.slice(0, e.start) + e.text + input.slice(e.end);
+    return input;
+};
+const internal = new Set(['preloadTranslation', 'initializeClient', 'syncFromState']);
+const translationModules = new Set(['@azure-net/kit/i18n', '@azure-net/edges-translations']);
+/** A conservative migration of known translation wiring, never a project-wide textual replacement. */
+export function migrateTranslationsSources(sources, resolve) {
+    const updates = new Map();
+    const issues = [];
+    const managers = [];
+    for (const [file, input] of sources) {
+        if (!/\.[jt]s$/.test(file))
+            continue;
+        const source = ts.createSourceFile(file, input, ts.ScriptTarget.Latest, true);
+        const factories = new Set();
+        for (const stmt of source.statements) {
+            if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier) || !translationModules.has(stmt.moduleSpecifier.text))
+                continue;
+            const bindings = stmt.importClause?.namedBindings;
+            if (bindings && ts.isNamedImports(bindings))
+                for (const b of bindings.elements)
+                    if ((b.propertyName ?? b.name).text === 'createTranslations')
+                        factories.add(b.name.text);
+        }
+        for (const stmt of source.statements)
+            if (ts.isVariableStatement(stmt) && stmt.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword))
+                for (const d of stmt.declarationList.declarations) {
+                    if (ts.isIdentifier(d.name) &&
+                        d.initializer &&
+                        ts.isCallExpression(d.initializer) &&
+                        ts.isIdentifier(d.initializer.expression) &&
+                        factories.has(d.initializer.expression.text))
+                        managers.push({ file, name: d.name.text });
+                }
+    }
+    if (!managers.length)
+        return { updates, issues };
+    if (managers.length !== 1) {
+        for (const m of managers)
+            issues.push({ file: m.file, reason: 'Multiple translation managers: choose the manager for app.useTranslations manually.' });
+        return { updates, issues };
+    }
+    const manager = managers[0];
+    const reaches = (file, seen = new Set()) => {
+        if (file === manager.file)
+            return true;
+        if (seen.has(file))
+            return false;
+        seen.add(file);
+        const source = ts.createSourceFile(file, sources.get(file) ?? '', ts.ScriptTarget.Latest, true);
+        return source.statements.some((s) => {
+            if ((!ts.isImportDeclaration(s) && !ts.isExportDeclaration(s)) || !s.moduleSpecifier || !ts.isStringLiteral(s.moduleSpecifier))
+                return false;
+            const target = resolve(file, s.moduleSpecifier.text);
+            return !!target && reaches(target, seen);
+        });
+    };
+    let connected = false;
+    for (const [file, input] of sources) {
+        if (!/\.[jt]s$/.test(file) || !reaches(file))
+            continue;
+        const source = ts.createSourceFile(file, input, ts.ScriptTarget.Latest, true);
+        const creators = new Set();
+        for (const stmt of source.statements)
+            if (ts.isImportDeclaration(stmt) && ts.isStringLiteral(stmt.moduleSpecifier) && stmt.moduleSpecifier.text === '@azure-net/kit') {
+                const b = stmt.importClause?.namedBindings;
+                if (b && ts.isNamedImports(b))
+                    for (const e of b.elements)
+                        if ((e.propertyName ?? e.name).text === 'createApp')
+                            creators.add(e.name.text);
+            }
+        const calls = [];
+        const visit = (n) => {
+            if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && creators.has(n.expression.text))
+                calls.push(n);
+            ts.forEachChild(n, visit);
+        };
+        visit(source);
+        if (!calls.length)
+            continue;
+        if (calls.length !== 1) {
+            issues.push({ file, reason: 'Multiple createApp calls: connect translations manually.' });
+            continue;
+        }
+        const callback = calls[0].arguments[0];
+        if (!callback || !ts.isArrowFunction(callback) || !callback.parameters[0] || !ts.isIdentifier(callback.parameters[0].name)) {
+            issues.push({ file, reason: 'Unsupported createApp callback: add useTranslations manually.' });
+            continue;
+        }
+        let body = ts.isBlock(callback.body)
+            ? callback.body.statements.find(ts.isReturnStatement)?.expression
+            : callback.body;
+        let already = false;
+        while (body && ts.isCallExpression(body) && ts.isPropertyAccessExpression(body.expression)) {
+            if (body.expression.name.text === 'useTranslations')
+                already = true;
+            body = body.expression.expression;
+        }
+        if (already) {
+            connected = true;
+            continue;
+        }
+        if (!body || !ts.isIdentifier(body) || body.text !== callback.parameters[0].name.text) {
+            issues.push({ file, reason: 'Unsupported createApp chain: add useTranslations manually.' });
+            continue;
+        }
+        let local = 'MigratedTranslationManager';
+        while (new RegExp(`\\b${local}\\b`).test(input))
+            local += '_';
+        let spec = path
+            .relative(path.dirname(file), manager.file)
+            .split(path.sep)
+            .join('/')
+            .replace(/\.[jt]s$/, '');
+        if (!spec.startsWith('.'))
+            spec = './' + spec;
+        updates.set(file, `import { ${manager.name} as ${local} } from ${JSON.stringify(spec)};\n` +
+            input.slice(0, body.end) +
+            `.useTranslations(${local})` +
+            input.slice(body.end));
+        connected = true;
+    }
+    if (!connected) {
+        issues.push({
+            file: manager.file,
+            reason: 'Translations require app.useTranslations(TranslationManager); no unambiguous connected bootstrap found.'
+        });
+        return { updates, issues };
+    }
+    let unsafeLifecycle = false;
+    for (const [file, original] of sources) {
+        if (!/\.[jt]s$/.test(file))
+            continue;
+        const input = updates.get(file) ?? original;
+        const source = ts.createSourceFile(file, input, ts.ScriptTarget.Latest, true);
+        const options = { noLib: true, noResolve: true };
+        const host = ts.createCompilerHost(options);
+        host.getSourceFile = (name) => (name === file ? source : undefined);
+        host.fileExists = (name) => name === file;
+        host.readFile = (name) => (name === file ? input : undefined);
+        const checker = ts.createProgram([file], options, host).getTypeChecker();
+        const accessors = new Set();
+        for (const stmt of source.statements)
+            if (ts.isImportDeclaration(stmt) &&
+                ts.isStringLiteral(stmt.moduleSpecifier) &&
+                resolve(file, stmt.moduleSpecifier.text) === manager.file) {
+                const bindings = stmt.importClause?.namedBindings;
+                if (bindings && ts.isNamedImports(bindings))
+                    for (const e of bindings.elements)
+                        if ((e.propertyName ?? e.name).text === manager.name)
+                            accessors.add(e.name.text);
+            }
+        const edits = [];
+        let unsafe = false;
+        const scan = (node) => {
+            if (ts.isVariableDeclaration(node) &&
+                ts.isObjectBindingPattern(node.name) &&
+                node.initializer &&
+                ts.isCallExpression(node.initializer) &&
+                ts.isIdentifier(node.initializer.expression) &&
+                accessors.has(node.initializer.expression.text)) {
+                const removed = node.name.elements.filter((b) => ts.isIdentifier(b.name) && internal.has((b.propertyName ?? b.name).getText(source)));
+                for (const b of removed) {
+                    const binding = checker.getSymbolAtLocation(b.name);
+                    const refs = [];
+                    const find = (n) => {
+                        if (n === node.name)
+                            return;
+                        if (binding && ts.isIdentifier(n) && checker.getSymbolAtLocation(n) === binding)
+                            refs.push(n);
+                        ts.forEachChild(n, find);
+                    };
+                    find(source);
+                    for (const ref of refs) {
+                        const call = ref.parent;
+                        if (!ts.isCallExpression(call) || call.expression !== ref || call.arguments.length) {
+                            unsafe = true;
+                            continue;
+                        }
+                        edits.push({ start: call.getStart(source), end: call.end, text: 'Promise.resolve()' });
+                    }
+                }
+                if (removed.length) {
+                    const kept = node.name.elements.filter((b) => !removed.includes(b));
+                    edits.push({
+                        start: node.name.getStart(source),
+                        end: node.name.end,
+                        text: `{ ${kept.map((b) => b.getText(source)).join(', ')} }`
+                    });
+                }
+            }
+            if (ts.isImportDeclaration(node) &&
+                ts.isStringLiteral(node.moduleSpecifier) &&
+                node.moduleSpecifier.text === '@azure-net/edges-translations')
+                edits.push({ start: node.moduleSpecifier.getStart(source), end: node.moduleSpecifier.end, text: "'@azure-net/kit/i18n'" });
+            ts.forEachChild(node, scan);
+        };
+        scan(source);
+        if (unsafe) {
+            unsafeLifecycle = true;
+            issues.push({ file, reason: 'Custom translation lifecycle arguments/references: migrate these calls manually to useTranslations.' });
+            continue;
+        }
+        if (edits.length)
+            updates.set(file, patch(input, edits));
+    }
+    // Do not connect automatic loading while an old custom locale resolver is still active.
+    return { updates: unsafeLifecycle ? new Map() : updates, issues };
+}