@unisphere/nx 4.9.0 → 4.11.0

package/dist/generators/add-runtime/add-runtime.d.ts

@@ -1,5 +1,5 @@
 import { Tree } from '@nx/devkit';
 import { AddRuntimeGeneratorSchema } from './schema';
-export declare function addRuntimeGenerator(tree: Tree, options: AddRuntimeGeneratorSchema): Promise<() => void>;
+export declare function addRuntimeGenerator(tree: Tree, options: AddRuntimeGeneratorSchema): Promise<any>;
 export default addRuntimeGenerator;
 //# sourceMappingURL=add-runtime.d.ts.map

package/dist/generators/add-runtime/add-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add-runtime.d.ts","sourceRoot":"","sources":["../../../src/generators/add-runtime/add-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,IAAI,EAAsC,MAAM,YAAY,CAAC;AAElG,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAgErD,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,yBAAyB,uBA4GnC;AAED,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"add-runtime.d.ts","sourceRoot":"","sources":["../../../src/generators/add-runtime/add-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,IAAI,EAAsC,MAAM,YAAY,CAAC;AAUlG,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AA0SrD,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,yBAAyB,gBAgHnC;AAED,eAAe,mBAAmB,CAAC"}

package/dist/generators/add-runtime/add-runtime.js

@@ -4,8 +4,10 @@ exports.addRuntimeGenerator = addRuntimeGenerator;
 const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
 const path = tslib_1.__importStar(require("path"));
+const ts_morph_1 = require("ts-morph");
 const utils_1 = require("../utils");
 const dependency_config_1 = require("../dependency-config");
+const visual_utils_1 = require("../add-visual/visual-utils");
 function validateOptions(options) {
     if (!options.name || options.name.trim() === '') {
         throw new Error(`Missing required option: 'name'\n` +
@@ -21,6 +23,150 @@ function validateOptions(options) {
             `  Received: ${options.name}`);
     }
 }
+function validateFlavorName(flavor) {
+    if (!flavor || flavor.trim() === '') {
+        throw new Error(`Missing required option: 'flavor'\n` +
+            `  Description: The name of the flavor to add\n` +
+            `  Pattern: ^[a-zA-Z][a-zA-Z0-9\\-\\s]*$`);
+    }
+    const namePattern = /^[a-zA-Z][a-zA-Z0-9\-\s]*$/;
+    if (!namePattern.test(flavor)) {
+        throw new Error(`Invalid value '${flavor}' for option 'flavor'\n` +
+            `  Pattern: ^[a-zA-Z][a-zA-Z0-9\\-\\s]*$\n` +
+            `  Received: ${flavor}`);
+    }
+    if ((0, devkit_1.names)(flavor).fileName === 'default') {
+        throw new Error(`Flavor name 'default' is reserved. The default flavor is runtime.tsx.\n` +
+            `  Please choose a different flavor name.`);
+    }
+}
+function updateCreateFactory(tree, sourceRoot, flavorNames, project) {
+    const factoryPath = [`${sourceRoot}/src/lib/create-factory.tsx`, `${sourceRoot}/src/lib/create-factory.ts`]
+        .find((p) => tree.exists(p));
+    if (!factoryPath) {
+        throw new Error(`Create factory file not found in ${sourceRoot}/src/lib/.\n` +
+            `  Expected: create-factory.tsx or create-factory.ts`);
+    }
+    const sourceFile = (0, visual_utils_1.loadSourceFile)(tree, factoryPath, project);
+    const flavorLowerDash = flavorNames['flavorName__lowerDashCase'];
+    const flavorPascal = flavorNames['flavorName__pascalCase'];
+    const className = `Runtime${flavorPascal}`;
+    const alreadyImported = sourceFile
+        .getImportDeclarations()
+        .some((decl) => decl.getNamedImports().some((imp) => imp.getName() === className));
+    if (alreadyImported) {
+        console.log(`⚠️ Import for ${className} already exists in create-factory.`);
+        return;
+    }
+    sourceFile.addImportDeclaration({
+        kind: ts_morph_1.StructureKind.ImportDeclaration,
+        namedImports: [className],
+        moduleSpecifier: `./runtime-${flavorLowerDash}`,
+    });
+    const switchStatement = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.SwitchStatement)[0];
+    if (!switchStatement) {
+        const createMethod = sourceFile
+            .getDescendantsOfKind(ts_morph_1.SyntaxKind.MethodDeclaration)
+            .find((m) => m.getName() === 'create');
+        (0, visual_utils_1.throwIfNotFound)(createMethod, `No 'create' method found in ${factoryPath}`);
+        const returnStatement = createMethod.getDescendantsOfKind(ts_morph_1.SyntaxKind.ReturnStatement)[0];
+        (0, visual_utils_1.throwIfNotFound)(returnStatement, `No return statement found in create method in ${factoryPath}`);
+        const returnExpr = returnStatement.getExpression()?.getText() || 'new Runtime(options)';
+        returnStatement.replaceWithText(`switch (options.flavor) {\n` +
+            `      case '${flavorLowerDash}':\n` +
+            `        return new ${className}(options) as any;\n` +
+            `      default:\n` +
+            `        return ${returnExpr};\n` +
+            `    }`);
+    }
+    else {
+        const caseBlock = switchStatement.getCaseBlock();
+        const cases = caseBlock.getClauses();
+        const caseExists = cases.some((c) => {
+            if (c.getKind() === ts_morph_1.SyntaxKind.CaseClause) {
+                const clause = c;
+                return clause.getExpression()?.getText().replace(/['"]/g, '') === flavorLowerDash;
+            }
+            return false;
+        });
+        if (caseExists) {
+            console.log(`⚠️ Switch case for flavor '${flavorLowerDash}' already exists.`);
+            return;
+        }
+        const newCase = `case '${flavorLowerDash}':\n        return new ${className}(options) as any;`;
+        const defaultIndex = cases.findIndex((c) => c.getKind() === ts_morph_1.SyntaxKind.DefaultClause);
+        if (defaultIndex !== -1) {
+            const defaultClause = cases[defaultIndex];
+            defaultClause.replaceWithText(`${newCase}\n      ${defaultClause.getText()}`);
+        }
+        else {
+            const lastCase = cases[cases.length - 1];
+            lastCase.replaceWithText(`${lastCase.getText()}\n      ${newCase}`);
+        }
+    }
+    (0, visual_utils_1.saveSourceFile)(tree, factoryPath, sourceFile.getFullText());
+    console.log(`✅ Updated create-factory with flavor '${flavorLowerDash}'`);
+}
+function updateFlavorTypesIndexExport(tree, runtimeName, flavorLowerDash, typesPackageInfo) {
+    const indexPath = `${typesPackageInfo.basePath}/src/lib/${runtimeName}-runtime/index.ts`;
+    if (!tree.exists(indexPath)) {
+        throw new Error(`Runtime types index not found at ${indexPath}`);
+    }
+    const currentContent = tree.read(indexPath, 'utf-8');
+    if (!currentContent) {
+        throw new Error(`Failed to read content from ${indexPath}`);
+    }
+    const exportLine = `export * from './runtime-${flavorLowerDash}-types';`;
+    if (currentContent.includes(exportLine)) {
+        return;
+    }
+    const updatedContent = currentContent.replace(/\n\n$/, '\n') + exportLine;
+    tree.write(indexPath, updatedContent);
+}
+async function addFlavorToRuntime(tree, options) {
+    const runtimeName = (0, devkit_1.names)(options.name).fileName;
+    const flavor = options.flavor;
+    validateFlavorName(flavor);
+    const unisphereConfig = (0, utils_1.validateUnisphereConfig)(tree);
+    const sourceRoot = (0, utils_1.validateRuntimeExists)(tree, runtimeName);
+    const typesPackageInfo = (0, utils_1.findTypesOrCorePackageInfo)(tree);
+    const flavorLowerDash = (0, devkit_1.names)(flavor).fileName;
+    const flavorFilePath = `${sourceRoot}/src/lib/runtime-${flavorLowerDash}.tsx`;
+    if (tree.exists(flavorFilePath)) {
+        throw new Error(`Flavor file already exists at ${flavorFilePath}.\n` +
+            `  Choose a different flavor name or remove the existing file.`);
+    }
+    const flavorTypesPath = `${typesPackageInfo.basePath}/src/lib/${runtimeName}-runtime/runtime-${flavorLowerDash}-types.ts`;
+    if (tree.exists(flavorTypesPath)) {
+        throw new Error(`Flavor types file already exists at ${flavorTypesPath}.\n` +
+            `  Choose a different flavor name or remove the existing file.`);
+    }
+    const runtimeNames = (0, utils_1.createNameTransforms)(runtimeName, 'runtimeName');
+    const flavorNames = (0, utils_1.createNameTransforms)(flavorLowerDash, 'flavorName');
+    const widgetNames = (0, utils_1.createNameTransforms)(unisphereConfig.name, 'widgetName');
+    const templateVariables = {
+        ...runtimeNames,
+        ...flavorNames,
+        ...widgetNames,
+        typesAlias: typesPackageInfo.alias,
+        tmpl: '',
+    };
+    (0, devkit_1.generateFiles)(tree, path.join(__dirname, 'templates/new-flavor'), `${sourceRoot}/src/lib`, templateVariables);
+    (0, devkit_1.generateFiles)(tree, path.join(__dirname, 'templates/new-flavor-types'), `${typesPackageInfo.basePath}/src/lib/${runtimeName}-runtime`, templateVariables);
+    updateFlavorTypesIndexExport(tree, runtimeName, flavorLowerDash, typesPackageInfo);
+    const project = new ts_morph_1.Project({
+        useInMemoryFileSystem: true,
+        skipAddingFilesFromTsConfig: true,
+    });
+    updateCreateFactory(tree, sourceRoot, flavorNames, project);
+    await (0, devkit_1.formatFiles)(tree);
+    console.log(`\n🎉 Successfully added flavor '${flavorLowerDash}' to runtime '${runtimeName}'!`);
+    console.log(`   Flavor file: ${flavorFilePath}`);
+    console.log(`   Types file: ${flavorTypesPath}`);
+    return () => {
+        return { runtimeName, flavor: flavorLowerDash };
+    };
+}
 function updateTypesIndexExport(tree, runtimeName, basePath) {
     const indexPath = `${basePath}/src/index.ts`;
     if (!tree.exists(indexPath)) {
@@ -41,6 +187,9 @@ function updateTypesIndexExport(tree, runtimeName, basePath) {
 }
 async function addRuntimeGenerator(tree, options) {
     validateOptions(options);
+    if (options.flavor) {
+        return addFlavorToRuntime(tree, options);
+    }
     // Validate and read .unisphere configuration
     const unisphereConfig = (0, utils_1.validateUnisphereConfig)(tree);
     // Validate dependencies

package/dist/generators/add-runtime/schema.d.ts

@@ -2,4 +2,5 @@ export interface AddRuntimeGeneratorSchema {
   name: string;
   dependencies?: string[];
   analyticsAppId?: number;
+  flavor?: string;
 }

package/dist/generators/add-runtime/schema.json

@@ -21,6 +21,11 @@
     "analyticsAppId": {
       "type": "number",
       "description": "Analytics app ID (optional, can be set later in runtime constructor)"
+    },
+    "flavor": {
+      "type": "string",
+      "description": "Name of the flavor to add to an existing runtime (e.g. 'player-plugin')",
+      "pattern": "^[a-zA-Z][a-zA-Z0-9\\-\\s]*$"
     }
   },
   "required": [

package/dist/generators/add-runtime/templates/new-flavor/runtime-__flavorName__.tsx.template

@@ -0,0 +1,63 @@
+import * as ReactDOM from 'react-dom/client';
+import { Root } from 'react-dom/client';
+import {
+  CreateElementOptions,
+  UnisphereRuntimeBase,
+} from '@unisphere/runtime-js';
+import {
+  <%= runtimeName__pascalCase %>Runtime<%= flavorName__pascalCase %>Settings,
+  <%= runtimeName__camelCase %>Runtime<%= flavorName__pascalCase %>SettingsSchema,
+  <%= runtimeName__pascalCase %>RuntimeName,
+  <%= runtimeName__pascalCase %><%= flavorName__pascalCase %>Runtime,
+  widgetName,
+} from '<%= typesAlias %>';
+import { HtmlDomRuntimeVisual } from '@unisphere/runtime';
+
+export class Runtime<%= flavorName__pascalCase %>
+  extends UnisphereRuntimeBase<<%= runtimeName__pascalCase %>Runtime<%= flavorName__pascalCase %>Settings, Root>
+  implements <%= runtimeName__pascalCase %><%= flavorName__pascalCase %>Runtime {
+  readonly id = widgetName;
+  readonly runtime = <%= runtimeName__pascalCase %>RuntimeName;
+  readonly widgetName = widgetName;
+  readonly runtimeName = <%= runtimeName__pascalCase %>RuntimeName;
+  readonly flavor = '<%= flavorName__lowerDashCase %>';
+
+  protected _onKilled(): void {
+    this._logger.log('runtime killed');
+  }
+
+  constructor(options: CreateElementOptions<<%= runtimeName__pascalCase %>Runtime<%= flavorName__pascalCase %>Settings>) {
+    super({
+      ...options,
+      settingsSchema: <%= runtimeName__camelCase %>Runtime<%= flavorName__pascalCase %>SettingsSchema,
+      visualTypes: {},
+    });
+
+    this._logger.log('runtime initialized', {
+      data: {
+        widgetName: this.widgetName,
+        runtimeName: this.runtimeName,
+        flavor: this.flavor,
+      },
+    });
+  }
+
+  override _createVisualContainer(htmlElement: HTMLElement): Root {
+    return ReactDOM.createRoot(htmlElement);
+  }
+
+  override _onVisualMount(visual: HtmlDomRuntimeVisual<Root>) {
+    switch (visual.type) {
+      default:
+        return false;
+    }
+  }
+
+  override _onVisualUnmount(visual: HtmlDomRuntimeVisual<Root>) {
+    visual.htmlContainer?.unmount();
+  }
+
+  protected _onSettingsUpdated(settings: <%= runtimeName__pascalCase %>Runtime<%= flavorName__pascalCase %>Settings) {
+    // use this method to react to settings changes
+  }
+}

package/dist/generators/add-runtime/templates/new-flavor-types/runtime-__flavorName__-types.ts.template

@@ -0,0 +1,20 @@
+import { ValidatorSchema } from '@unisphere/core';
+import { UnisphereRuntimeBaseType } from '@unisphere/runtime';
+import { widgetName } from '../widget-types';
+import { <%= runtimeName__pascalCase %>RuntimeName } from './runtime-types';
+
+export interface <%= runtimeName__pascalCase %>Runtime<%= flavorName__pascalCase %>Settings {
+  schemaVersion?: string;
+}
+
+export const <%= runtimeName__camelCase %>Runtime<%= flavorName__pascalCase %>SettingsSchema: ValidatorSchema = {
+  type: 'object',
+  properties: {
+    schemaVersion: { type: 'literal', value: '1', optional: true },
+  },
+};
+
+export type <%= runtimeName__pascalCase %><%= flavorName__pascalCase %>Runtime = UnisphereRuntimeBaseType<<%= runtimeName__pascalCase %>Runtime<%= flavorName__pascalCase %>Settings> & {
+  readonly widgetName: typeof widgetName;
+  readonly runtimeName: typeof <%= runtimeName__pascalCase %>RuntimeName;
+}

package/dist/generators/add-runtime/templates/new-runtime/src/lib/runtime.tsx.template

@@ -9,9 +9,9 @@ import {
   <%= runtimeName__pascalCase %>RuntimeName,
   <%= runtimeName__pascalCase %>RuntimeSettings,
   <%= runtimeName__camelCase %>RuntimeSettingsSchema,
+  widgetName,
 } from '<%= typesAlias %>';
 import { HtmlDomRuntimeVisual, KalturaAnalyticsServiceType } from '@unisphere/runtime';
-import { widgetName } from '<%= typesAlias %>'
 
 export class Runtime
   extends UnisphereRuntimeBase<<%= runtimeName__pascalCase %>RuntimeSettings, Root>

package/dist/generators/add-visual/add-visual.d.ts

@@ -1,5 +1,7 @@
 import { Tree } from '@nx/devkit';
 import { AddVisualGeneratorSchema } from './schema';
+export declare function discoverAvailableFlavors(tree: Tree, sourceRoot: string): string[];
+export declare function resolveTargetFile(tree: Tree, sourceRoot: string, flavor: string | undefined): string;
 /**
  * Nx generator to create a new visual within a specified runtime.
  */

package/dist/generators/add-visual/add-visual.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add-visual.d.ts","sourceRoot":"","sources":["../../../src/generators/add-visual/add-visual.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,IAAI,EAAE,MAAM,YAAY,CAAC;AAsB9D,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAmapD;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,GAAG,CAAC,CA2Fd;AAED,eAAe,kBAAkB,CAAC"}
+{"version":3,"file":"add-visual.d.ts","sourceRoot":"","sources":["../../../src/generators/add-visual/add-visual.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,IAAI,EAAE,MAAM,YAAY,CAAC;AAsB9D,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAapD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAUjF;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,MAAM,CAuBR;AAwZD;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,GAAG,CAAC,CA6Ed;AAED,eAAe,kBAAkB,CAAC"}

package/dist/generators/add-visual/add-visual.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverAvailableFlavors = discoverAvailableFlavors;
+exports.resolveTargetFile = resolveTargetFile;
 exports.addVisualGenerator = addVisualGenerator;
 const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
@@ -7,6 +9,37 @@ const path = tslib_1.__importStar(require("path"));
 const ts_morph_1 = require("ts-morph");
 const utils_1 = require("../utils");
 const visual_utils_1 = require("./visual-utils");
+function discoverAvailableFlavors(tree, sourceRoot) {
+    const libDir = `${sourceRoot}/src/lib`;
+    if (!tree.exists(libDir)) {
+        return [];
+    }
+    return tree
+        .children(libDir)
+        .filter((f) => /^(runtime-.+|.+-runtime-base)\.tsx$/.test(f))
+        .map((f) => f.replace('.tsx', ''))
+        .sort();
+}
+function resolveTargetFile(tree, sourceRoot, flavor) {
+    const libDir = `${sourceRoot}/src/lib`;
+    if (!flavor) {
+        const defaultPath = `${libDir}/runtime.tsx`;
+        if (!tree.exists(defaultPath)) {
+            throw new Error(`Default runtime file not found at ${defaultPath}`);
+        }
+        return defaultPath;
+    }
+    const targetPath = `${libDir}/${flavor}.tsx`;
+    if (!tree.exists(targetPath)) {
+        const available = discoverAvailableFlavors(tree, sourceRoot);
+        throw new Error(`Flavor file '${flavor}.tsx' not found in ${libDir}.\n` +
+            (available.length > 0
+                ? `  Available flavors: ${available.join(', ')}\n`
+                : '') +
+            `  Omit --flavor to target the default runtime.`);
+    }
+    return targetPath;
+}
 function validateOptions(options) {
     if (!options.runtimeName || options.runtimeName.trim() === '') {
         throw new Error(`Missing required option: 'runtimeName'\n` +
@@ -130,8 +163,7 @@ function addVisualTypesToConstructor(sourceFilePath, tree, vars, project, isSing
     const visualTypesProp = (0, visual_utils_1.throwIfNotFound)(objectLiteral
         .getProperties()
         .find((prop) => prop.getKind() === ts_morph_1.SyntaxKind.PropertyAssignment &&
-        prop.getName() === 'visualTypes'), // Assert type after finding
-    `Could not find visualTypes property in super() call in ${sourceFilePath}`);
+        ['visualTypes', 'flavorVisualTypes'].includes(prop.getName())), `Could not find visualTypes or flavorVisualTypes property in super() call in ${sourceFilePath}`);
     const visualTypesObject = (0, visual_utils_1.throwIfNotFound)(visualTypesProp.getInitializer(), // Assert type after getting initializer
     `visualTypes is not an object literal in ${sourceFilePath}`);
     if ((0, visual_utils_1.propertyExists)(visualTypesObject, visualCamel)) {
@@ -287,18 +319,14 @@ async function addVisualGenerator(tree, options) {
     const isSingleOccurrence = options.isSingleOccurrence ?? false;
     // Extract environment variables
     const widgetName = unisphereConfig.name;
-    // Validate runtime existence and get source root path.
     const runtimeSourceRoot = (0, utils_1.validateRuntimeExists)(tree, runtimeName);
-    const runtimeTSxPath = `${runtimeSourceRoot}/src/lib/runtime.tsx`;
-    // Find types package (or fallback to core)
+    const targetFile = resolveTargetFile(tree, runtimeSourceRoot, options.flavor);
     const typesPackageInfo = (0, utils_1.findTypesOrCorePackageInfo)(tree);
     const runtimeNames = (0, utils_1.createNameTransforms)(runtimeName, 'runtimeName');
     const visualNames = (0, utils_1.createNameTransforms)(visualName, 'visualName');
     const widgetNames = (0, utils_1.createNameTransforms)(widgetName, 'widgetName');
-    // Derive specific names for runtime visual settings and schema based on transforms.
     const runtimeVisualSettings = `${runtimeNames.runtimeName__pascalCase}Runtime${visualNames.visualName__pascalCase}VisualSettings`;
     const runtimeVisualSchema = `${runtimeNames.runtimeName__camelCase}Runtime${visualNames.visualName__pascalCase}VisualSettingsSchema`;
-    // Combine all template variables for easy access and passing to functions.
     const templateVariables = {
         ...runtimeNames,
         ...visualNames,
@@ -307,30 +335,25 @@ async function addVisualGenerator(tree, options) {
         runtimeVisualSchema,
         typesAlias: typesPackageInfo.alias,
     };
-    // Ensure the target runtime file exists before proceeding.
-    if (!tree.exists(runtimeTSxPath)) {
-        throw new Error(`Runtime file not found at ${runtimeTSxPath}`);
-    }
-    // Initialize ts-morph project with an in-memory file system for modifications.
     const project = new ts_morph_1.Project({
         useInMemoryFileSystem: true,
         skipAddingFilesFromTsConfig: true,
     });
-    // Execute all code modification steps.
-    addImportToRuntime(runtimeTSxPath, tree, templateVariables, project);
-    addVisualTypesToConstructor(runtimeTSxPath, tree, templateVariables, project, isSingleOccurrence);
-    addSwitchCaseToRuntime(runtimeTSxPath, tree, templateVariables, project);
-    addRenderMethod(runtimeTSxPath, tree, templateVariables, project, typesPackageInfo);
-    // 'project' parameter is not needed here as createVisualTypes directly writes to the tree.
+    if (options.flavor) {
+        console.log(`\nProcessing flavor '${options.flavor}'...`);
+    }
+    addImportToRuntime(targetFile, tree, templateVariables, project);
+    addVisualTypesToConstructor(targetFile, tree, templateVariables, project, isSingleOccurrence);
+    addSwitchCaseToRuntime(targetFile, tree, templateVariables, project);
+    addRenderMethod(targetFile, tree, templateVariables, project, typesPackageInfo);
     createVisualTypes(tree, templateVariables, typesPackageInfo);
-    // Format all modified files for consistent code style.
     await (0, devkit_1.formatFiles)(tree);
-    // Log success and summary information to the console.
-    console.log(`\n🎉 Successfully added visual '${visualName}' to runtime '${runtimeName}'!`);
+    const flavorSummary = options.flavor ? ` (flavor: ${options.flavor})` : '';
+    console.log(`\n🎉 Successfully added visual '${visualName}' to runtime '${runtimeName}'${flavorSummary}!`);
     console.log(`   Runtime: ${runtimeName} (${runtimeSourceRoot})`);
+    console.log(`   Target: ${targetFile}`);
     console.log(`   Visual: ${visualName}`);
     console.log(`   Single occurrence: ${isSingleOccurrence ? 'Yes' : 'No'}`);
-    console.log(`   Modified file: ${runtimeTSxPath}`);
     return () => {
         return { visualName };
     };

package/dist/generators/add-visual/schema.d.ts

@@ -2,4 +2,5 @@ export interface AddVisualGeneratorSchema {
   runtimeName?: string;
   visualName?: string;
   isSingleOccurrence?: boolean;
+  flavor?: string;
 }

package/dist/generators/add-visual/schema.json

@@ -18,6 +18,10 @@
       "type": "boolean",
       "description": "Whether this visual is limited to single occurrence",
       "default": false
+    },
+    "flavor": {
+      "type": "string",
+      "description": "Target file name without .tsx extension (e.g. 'runtime-player-plugin', 'chat-runtime-base'). Omit to target the default runtime.tsx."
     }
   },
   "required": ["runtimeName", "visualName"]

package/dist/migrations/4-10-1/add-get-workspace-to-get-service.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Migration: Add getWorkspace() call before getService in runtime files
+ *
+ * Transforms this._options.getService to this._options.getWorkspace().getService
+ * in runtime project files.
+ */
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;
+//# sourceMappingURL=add-get-workspace-to-get-service.d.ts.map

package/dist/migrations/4-10-1/add-get-workspace-to-get-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-get-workspace-to-get-service.d.ts","sourceRoot":"","sources":["../../../src/migrations/4-10-1/add-get-workspace-to-get-service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,IAAI,EAA6C,MAAM,YAAY,CAAC;AAE7E,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CA0D9D"}

package/dist/migrations/4-10-1/add-get-workspace-to-get-service.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Migration: Add getWorkspace() call before getService in runtime files
+ *
+ * Transforms this._options.getService to this._options.getWorkspace().getService
+ * in runtime project files.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+async function update(tree) {
+    devkit_1.logger.info('🔄 Adding getWorkspace() before getService calls in runtime projects...');
+    const runtimesDir = 'unisphere/runtimes';
+    if (!tree.exists(runtimesDir)) {
+        devkit_1.logger.info('ℹ️ No runtimes directory found');
+        return;
+    }
+    let updatedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, runtimesDir, (filePath) => {
+        if (!filePath.endsWith('.ts') && !filePath.endsWith('.tsx'))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        if (!content.includes('_options') || !content.includes('getService'))
+            return;
+        // Match this._options followed by optional whitespace/newline/dot then .getService
+        // Handles: this._options.getService / this._options.\n      .getService / this._options\n      .getService
+        const pattern = /this\._options\.?\s*\.getService/g;
+        if (!pattern.test(content))
+            return;
+        // Already migrated check: if getWorkspace().getService exists, skip
+        if (content.includes('.getWorkspace().getService') || content.includes('.getWorkspace()\n')) {
+            // More precise check: see if all occurrences are already migrated
+            const unmigrated = content.replace(/this\._options\.getWorkspace\(\)\s*\.getService/g, '');
+            if (!/this\._options\.?\s*\.getService/.test(unmigrated)) {
+                return;
+            }
+        }
+        const updatedContent = content.replace(/this\._options\.?\s*\.\s*getService/g, 'this._options.getWorkspace().getService');
+        if (updatedContent !== content) {
+            tree.write(filePath, updatedContent);
+            updatedCount++;
+            devkit_1.logger.info(`  ✅ Updated ${filePath}`);
+        }
+    });
+    if (updatedCount === 0) {
+        devkit_1.logger.info('ℹ️ No runtime files needed getWorkspace() insertion before getService');
+    }
+    else {
+        await (0, devkit_1.formatFiles)(tree);
+        devkit_1.logger.info(`✅ Updated ${updatedCount} runtime file(s)`);
+    }
+}

package/dist/migrations/4-10-1/update-unisphere-visual-target.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Migration: Update UnisphereVisualTarget usage
+ *
+ * 1. Renames `target` property to `type` in visual target object literals
+ *    (where value is 'body' or 'element')
+ * 2. Converts string visual targets to { type: 'element', elementId: '<string>' }
+ */
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;
+//# sourceMappingURL=update-unisphere-visual-target.d.ts.map

package/dist/migrations/4-10-1/update-unisphere-visual-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-unisphere-visual-target.d.ts","sourceRoot":"","sources":["../../../src/migrations/4-10-1/update-unisphere-visual-target.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,IAAI,EAA6C,MAAM,YAAY,CAAC;AAS7E,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAoF9D"}

package/dist/migrations/4-10-1/update-unisphere-visual-target.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * Migration: Update UnisphereVisualTarget usage
+ *
+ * 1. Renames `target` property to `type` in visual target object literals
+ *    (where value is 'body' or 'element')
+ * 2. Converts string visual targets to { type: 'element', elementId: '<string>' }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const ts_morph_1 = require("ts-morph");
+async function update(tree) {
+    devkit_1.logger.info('🔄 Updating UnisphereVisualTarget usage...');
+    const project = new ts_morph_1.Project({
+        manipulationSettings: { quoteKind: ts_morph_1.QuoteKind.Single },
+    });
+    let updatedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!filePath.endsWith('.ts') && !filePath.endsWith('.tsx'))
+            return;
+        if (!filePath.includes('unisphere/'))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        if (!content.includes('target'))
+            return;
+        const sourceFile = project.createSourceFile(filePath, content, {
+            overwrite: true,
+        });
+        let hasChanges = false;
+        // Pass 1: Rename target → type in object literals where value is 'body' or 'element'
+        // Only in visual target contexts (mountVisual args, visuals config, nested in target property)
+        const allPropertyAssignments = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.PropertyAssignment);
+        for (const prop of allPropertyAssignments) {
+            if (prop.getName() !== 'target')
+                continue;
+            const initializer = prop.getInitializerIfKind(ts_morph_1.SyntaxKind.StringLiteral);
+            if (!initializer)
+                continue;
+            const value = initializer.getLiteralValue();
+            if (value !== 'body' && value !== 'element')
+                continue;
+            if (!isVisualTargetObjectContext(prop))
+                continue;
+            prop.getNameNode().replaceWithText('type');
+            hasChanges = true;
+        }
+        // Pass 2: Convert string targets to objects in mountVisual calls and visuals config
+        // Re-query after Pass 1 modifications
+        const propertyAssignments = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.PropertyAssignment);
+        for (const prop of propertyAssignments) {
+            if (prop.getName() !== 'target')
+                continue;
+            const initializer = prop.getInitializerIfKind(ts_morph_1.SyntaxKind.StringLiteral);
+            if (!initializer)
+                continue;
+            const value = initializer.getLiteralValue();
+            // Skip 'body' and 'element' - those were handled in Pass 1
+            if (value === 'body' || value === 'element')
+                continue;
+            // Check if this is in a visual target context
+            if (!isVisualTargetContext(prop))
+                continue;
+            // Transform string to { type: 'element', elementId: '<string>' }
+            initializer.replaceWithText(`{ type: 'element', elementId: '${value}' }`);
+            hasChanges = true;
+        }
+        if (hasChanges) {
+            tree.write(filePath, sourceFile.getFullText());
+            updatedCount++;
+            devkit_1.logger.info(`  ✅ Updated ${filePath}`);
+        }
+    });
+    if (updatedCount === 0) {
+        devkit_1.logger.info('ℹ️ No UnisphereVisualTarget usages needed transformation');
+    }
+    else {
+        await (0, devkit_1.formatFiles)(tree);
+        devkit_1.logger.info(`✅ Updated UnisphereVisualTarget usage in ${updatedCount} file(s)`);
+    }
+}
+/**
+ * Checks if a `target` property with value 'body'/'element' is inside a UnisphereVisualTarget object.
+ * The object itself (containing target: 'body') is the visual target value, so we check
+ * whether it's nested inside a `target` property of a parent, a mountVisual call, or visuals array.
+ */
+function isVisualTargetObjectContext(prop) {
+    const objLiteral = prop.getParent();
+    if (!ts_morph_1.Node.isObjectLiteralExpression(objLiteral))
+        return false;
+    const objParent = objLiteral.getParent();
+    // Context 1: Object is value of a `target` property in a parent object
+    // e.g., mountVisual({ target: { target: 'body' } }) — inner object is the visual target
+    if (ts_morph_1.Node.isPropertyAssignment(objParent) && objParent.getName() === 'target')
+        return true;
+    // Context 2: Object is inside a mountVisual() call directly
+    // e.g., mountVisual({ target: 'body' }) — less common but possible
+    if (ts_morph_1.Node.isCallExpression(objParent)) {
+        const expr = objParent.getExpression();
+        if (expr.getText().endsWith('mountVisual'))
+            return true;
+    }
+    // Context 3: Object is inside a visuals array item's target property
+    // e.g., visuals: [{ target: { target: 'body' } }]
+    if (ts_morph_1.Node.isPropertyAssignment(objParent) && objParent.getName() === 'target') {
+        const outerObj = objParent.getParent();
+        if (ts_morph_1.Node.isObjectLiteralExpression(outerObj)) {
+            const arrayParent = outerObj.getParent();
+            if (ts_morph_1.Node.isArrayLiteralExpression(arrayParent)) {
+                const arrayPropParent = arrayParent.getParent();
+                if (ts_morph_1.Node.isPropertyAssignment(arrayPropParent) &&
+                    arrayPropParent.getName() === 'visuals')
+                    return true;
+            }
+        }
+    }
+    // Context 4: Object has sibling properties that indicate it's a visual target
+    // (has elementId for 'element' type, or classNames/style for 'body' type)
+    if (objLiteral.getProperty('elementId'))
+        return true;
+    if (objLiteral.getProperty('classNames'))
+        return true;
+    if (objLiteral.getProperty('style'))
+        return true;
+    return false;
+}
+/**
+ * Checks if a `target` property with a string value is in a visual target context
+ * (the string IS the visual target value, needing conversion to object).
+ */
+function isVisualTargetContext(prop) {
+    const parent = prop.getParent();
+    if (!ts_morph_1.Node.isObjectLiteralExpression(parent))
+        return false;
+    // Context 1: Inside mountVisual() call argument
+    // e.g., super.mountVisual({ type: 'popup', target: 'someId', settings: {} })
+    const grandparent = parent.getParent();
+    if (ts_morph_1.Node.isCallExpression(grandparent)) {
+        const expr = grandparent.getExpression();
+        if (expr.getText().endsWith('mountVisual'))
+            return true;
+    }
+    // Context 2: Inside a visuals array item
+    // e.g., visuals: [{ target: 'someId', ... }]
+    if (ts_morph_1.Node.isArrayLiteralExpression(grandparent)) {
+        const arrayParent = grandparent.getParent();
+        if (ts_morph_1.Node.isPropertyAssignment(arrayParent)) {
+            if (arrayParent.getName() === 'visuals')
+                return true;
+        }
+    }
+    // Context 3: Parent object has siblings suggesting visual config
+    // (has 'type' property with value like 'popup', 'inline', etc.)
+    const typeProp = parent.getProperty('type');
+    if (typeProp && ts_morph_1.Node.isPropertyAssignment(typeProp)) {
+        const typeInit = typeProp.getInitializerIfKind(ts_morph_1.SyntaxKind.StringLiteral);
+        if (typeInit) {
+            const typeValue = typeInit.getLiteralValue();
+            if (typeValue === 'popup' ||
+                typeValue === 'inline' ||
+                typeValue === 'drawer')
+                return true;
+        }
+    }
+    return false;
+}

package/dist/migrations/4-10-1/wrap-tiny-data-store-initial-value.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Migration: Wrap TinyDataStore/TinyStorage constructor arguments in initialValue
+ *
+ * Transforms constructor calls to wrap the argument in an { initialValue: ... } object.
+ * Skips instances that already have an initialValue property.
+ */
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;
+//# sourceMappingURL=wrap-tiny-data-store-initial-value.d.ts.map

package/dist/migrations/4-10-1/wrap-tiny-data-store-initial-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-tiny-data-store-initial-value.d.ts","sourceRoot":"","sources":["../../../src/migrations/4-10-1/wrap-tiny-data-store-initial-value.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,IAAI,EAA6C,MAAM,YAAY,CAAC;AAK7E,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAmE9D"}

package/dist/migrations/4-10-1/wrap-tiny-data-store-initial-value.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Migration: Wrap TinyDataStore/TinyStorage constructor arguments in initialValue
+ *
+ * Transforms constructor calls to wrap the argument in an { initialValue: ... } object.
+ * Skips instances that already have an initialValue property.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const ts_morph_1 = require("ts-morph");
+const TARGET_CLASSES = ['TinyDataStore', 'TinyStorage'];
+async function update(tree) {
+    devkit_1.logger.info('🔄 Wrapping TinyDataStore/TinyStorage constructor arguments in initialValue...');
+    const project = new ts_morph_1.Project({
+        manipulationSettings: { quoteKind: ts_morph_1.QuoteKind.Single },
+    });
+    let updatedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!filePath.endsWith('.ts') && !filePath.endsWith('.tsx'))
+            return;
+        if (!filePath.includes('unisphere/'))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        if (!TARGET_CLASSES.some((cls) => content.includes(cls)))
+            return;
+        const sourceFile = project.createSourceFile(filePath, content, {
+            overwrite: true,
+        });
+        let hasChanges = false;
+        const newExpressions = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.NewExpression);
+        for (const expr of newExpressions) {
+            const exprText = expr.getExpression().getText();
+            if (!TARGET_CLASSES.includes(exprText))
+                continue;
+            const args = expr.getArguments();
+            if (args.length !== 1)
+                continue;
+            const arg = args[0];
+            // Skip if argument already has an initialValue property
+            if (arg.getKind() === ts_morph_1.SyntaxKind.ObjectLiteralExpression) {
+                const objLiteral = arg.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+                if (objLiteral?.getProperty('initialValue'))
+                    continue;
+            }
+            const argText = arg.getText();
+            arg.replaceWithText(`{\n      initialValue: ${argText},\n    }`);
+            hasChanges = true;
+        }
+        if (hasChanges) {
+            tree.write(filePath, sourceFile.getFullText());
+            updatedCount++;
+            devkit_1.logger.info(`  ✅ Updated ${filePath}`);
+        }
+    });
+    if (updatedCount === 0) {
+        devkit_1.logger.info('ℹ️ No TinyDataStore/TinyStorage instances needed transformation');
+    }
+    else {
+        await (0, devkit_1.formatFiles)(tree);
+        devkit_1.logger.info(`✅ Wrapped constructor arguments in initialValue for ${updatedCount} file(s)`);
+    }
+}

package/dist/migrations/4-11-0/migrate-analytics-types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Migration: Migrate Kava analytics types to Application Events bucket types
+ *
+ * Renames enums/types and adds the required `bucket: AnalyticsBucket.ApplicationEvents`
+ * field to all report() calls.
+ */
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<void>;
+//# sourceMappingURL=migrate-analytics-types.d.ts.map

package/dist/migrations/4-11-0/migrate-analytics-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate-analytics-types.d.ts","sourceRoot":"","sources":["../../../src/migrations/4-11-0/migrate-analytics-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,IAAI,EAA6C,MAAM,YAAY,CAAC;AAa7E,wBAA8B,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CA2G9D"}

package/dist/migrations/4-11-0/migrate-analytics-types.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Migration: Migrate Kava analytics types to Application Events bucket types
+ *
+ * Renames enums/types and adds the required `bucket: AnalyticsBucket.ApplicationEvents`
+ * field to all report() calls.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const ts_morph_1 = require("ts-morph");
+const RENAMES = {
+    KavaEventTypes: 'ApplicationEventTypes',
+    KavaButtonsTypes: 'ApplicationButtonTypes',
+    KavaPageTypes: 'ApplicationPageTypes',
+    KavaBaseTypePayload: 'ApplicationEventsBasePayload',
+    KavaButtonTypePayload: 'ApplicationButtonPayload',
+    KavaPageTypePayload: 'ApplicationPagePayload',
+    KavaRequestPayloadByType: 'AnalyticsPayloadByBucket',
+};
+async function update(tree) {
+    devkit_1.logger.info('🔄 Migrating Kava analytics types to Application Events bucket types...');
+    const runtimesDir = 'unisphere/runtimes';
+    if (!tree.exists(runtimesDir)) {
+        devkit_1.logger.info('ℹ️ No runtimes directory found');
+        return;
+    }
+    const project = new ts_morph_1.Project({
+        manipulationSettings: { quoteKind: ts_morph_1.QuoteKind.Single },
+    });
+    let updatedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, runtimesDir, (filePath) => {
+        if (!filePath.endsWith('.ts') && !filePath.endsWith('.tsx'))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content)
+            return;
+        const hasOldTypes = Object.keys(RENAMES).some((old) => content.includes(old));
+        if (!hasOldTypes)
+            return;
+        const sourceFile = project.createSourceFile(filePath, content, {
+            overwrite: true,
+        });
+        let hasChanges = false;
+        // Step 1: Add `bucket: AnalyticsBucket.ApplicationEvents` to any object literal
+        // containing an `eventType: KavaEventTypes.*` property (covers direct .report() calls
+        // and indirect patterns like wrapper functions).
+        const objectLiterals = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+        for (const objLiteral of objectLiterals) {
+            if (objLiteral.getProperty('bucket'))
+                continue;
+            const eventTypeProp = objLiteral.getProperty('eventType');
+            if (!eventTypeProp)
+                continue;
+            const eventTypeText = eventTypeProp.getText();
+            if (!eventTypeText.includes('KavaEventTypes.') &&
+                !eventTypeText.includes('ApplicationEventTypes.'))
+                continue;
+            objLiteral.insertPropertyAssignment(0, {
+                name: 'bucket',
+                initializer: 'AnalyticsBucket.ApplicationEvents',
+            });
+            hasChanges = true;
+        }
+        // Step 2: Rename all old type/enum references
+        let updatedText = sourceFile.getFullText();
+        for (const [oldName, newName] of Object.entries(RENAMES)) {
+            const regex = new RegExp(`\\b${oldName}\\b`, 'g');
+            if (regex.test(updatedText)) {
+                updatedText = updatedText.replace(regex, newName);
+                hasChanges = true;
+            }
+        }
+        // Step 3: Add AnalyticsBucket to imports from @unisphere/runtime
+        if (hasChanges) {
+            if (updatedText.includes('AnalyticsBucket') &&
+                !updatedText.match(/import\s*\{[^}]*AnalyticsBucket[^}]*\}\s*from\s*['"]@unisphere\/runtime['"]/)) {
+                updatedText = updatedText.replace(/(import\s*\{)([^}]*)(}\s*from\s*['"]@unisphere\/runtime['"])/, (_match, start, imports, end) => {
+                    const importList = imports
+                        .split(',')
+                        .map((s) => s.trim())
+                        .filter(Boolean);
+                    if (!importList.includes('AnalyticsBucket')) {
+                        importList.push('AnalyticsBucket');
+                        importList.sort();
+                    }
+                    return `${start}\n  ${importList.join(',\n  ')},\n${end}`;
+                });
+            }
+            tree.write(filePath, updatedText);
+            updatedCount++;
+            devkit_1.logger.info(`  ✅ Updated ${filePath}`);
+        }
+    });
+    if (updatedCount === 0) {
+        devkit_1.logger.info('ℹ️ No files needed analytics type migration');
+    }
+    else {
+        await (0, devkit_1.formatFiles)(tree);
+        devkit_1.logger.info(`✅ Migrated analytics types in ${updatedCount} file(s)`);
+    }
+}

package/migrations.json

@@ -458,6 +458,38 @@
       "cli": {
         "postUpdateMessage": "✅ Security Audit step restored in cicd.yml"
       }
+    },
+    "4-10-1-wrap-tiny-data-store-initial-value": {
+      "version": "4.10.1",
+      "description": "Wraps TinyDataStore/TinyStorage constructor arguments in initialValue property",
+      "factory": "./dist/migrations/4-10-1/wrap-tiny-data-store-initial-value.js",
+      "cli": {
+        "postUpdateMessage": "✅ TinyDataStore/TinyStorage constructor arguments wrapped in initialValue"
+      }
+    },
+    "4-10-1-add-get-workspace-to-get-service": {
+      "version": "4.10.1",
+      "description": "Adds getWorkspace() call before getService in runtime files",
+      "factory": "./dist/migrations/4-10-1/add-get-workspace-to-get-service.js",
+      "cli": {
+        "postUpdateMessage": "✅ Runtime files updated: this._options.getService → this._options.getWorkspace().getService"
+      }
+    },
+    "4-10-1-update-unisphere-visual-target": {
+      "version": "4.10.1",
+      "description": "Updates UnisphereVisualTarget usage: renames target→type, converts string targets to objects",
+      "factory": "./dist/migrations/4-10-1/update-unisphere-visual-target.js",
+      "cli": {
+        "postUpdateMessage": "✅ UnisphereVisualTarget usage updated (target→type, string→object)"
+      }
+    },
+    "4-11-0-migrate-analytics-types": {
+      "version": "4.11.0",
+      "description": "Migrates Kava analytics types to Application Events bucket types (KavaEventTypes→ApplicationEventTypes, KavaButtonsTypes→ApplicationButtonTypes, adds bucket field)",
+      "factory": "./dist/migrations/4-11-0/migrate-analytics-types.js",
+      "cli": {
+        "postUpdateMessage": "✅ Analytics types migrated to Application Events bucket pattern"
+      }
     }
   },
   "packageJsonUpdates": {
@@ -791,6 +823,29 @@
           "alwaysAddToPackageJson": false
         }
       }
+    },
+    "4.10.1": {
+      "version": "4.10.1",
+      "cli": "nx",
+      "postUpdateMessage": "🎉 Migration to @unisphere/nx 4.10.1 completed successfully!",
+      "packages": {
+        "@unisphere/core": {
+          "version": "^1.97.1",
+          "alwaysAddToPackageJson": false
+        },
+        "@unisphere/runtime": {
+          "version": "^1.97.0",
+          "alwaysAddToPackageJson": false
+        },
+        "@unisphere/runtime-js": {
+          "version": "^1.93.0",
+          "alwaysAddToPackageJson": false
+        },
+        "@unisphere/runtime-react": {
+          "version": "^1.87.0",
+          "alwaysAddToPackageJson": false
+        }
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unisphere/nx",
-  "version": "4.9.0",
+  "version": "4.11.0",
   "private": false,
   "main": "./dist/index.js",
   "module": "./dist/index.js",