Enhance refactor commands with controller-aware Route() updates and fix code quality violations

Add semantic token highlighting for 'that' variable and comment file references in VS Code extension
Add Phone_Text_Input and Currency_Input components with formatting utilities
Implement client widgets, form standardization, and soft delete functionality
Add modal scroll lock and update documentation
Implement comprehensive modal system with form integration and validation
Fix modal component instantiation using jQuery plugin API
Implement modal system with responsive sizing, queuing, and validation support
Implement form submission with validation, error handling, and loading states
Implement country/state selectors with dynamic data loading and Bootstrap styling
Revert Rsx::Route() highlighting in Blade/PHP files
Target specific PHP scopes for Rsx::Route() highlighting in Blade
Expand injection selector for Rsx::Route() highlighting
Add custom syntax highlighting for Rsx::Route() and Rsx.Route() calls
Update jqhtml packages to v2.2.165
Add bundle path validation for common mistakes (development mode only)
Create Ajax_Select_Input widget and Rsx_Reference_Data controller
Create Country_Select_Input widget with default country support
Initialize Tom Select on Select_Input widgets
Add Tom Select bundle for enhanced select dropdowns
Implement ISO 3166 geographic data system for country/region selection
Implement widget-based form system with disabled state support

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

node_modules/@rollup/plugin-node-resolve/dist/cjs/index.js

@@ -12,7 +12,7 @@ var url = require('url');
 var resolve = require('resolve');
 var pluginutils = require('@rollup/pluginutils');
 
-var version = "16.0.1";
+var version = "16.0.3";
 var peerDependencies = {
 	rollup: "^2.78.0||^3.0.0||^4.0.0"
 };
@@ -787,9 +787,18 @@ async function resolveWithExportMap({
       importer,
       moduleDirs: moduleDirectories,
       conditions: exportConditions,
+      // Resolve targets of "imports" mappings using the same algorithm
+      // we use for normal specifiers: try export maps first and then
+      // fall back to classic resolution. This is important for cases
+      // like "#foo/*": "@scope/pkg/*" where the target package relies
+      // on "exports" to expose subpaths. Using the classic resolver
+      // alone would fail to find those subpaths.
       resolveId(id /* , parent*/) {
-        return resolveIdClassic({
-          importSpecifier: id,
+        return resolveImportSpecifiers({
+          importer,
+          importSpecifierList: [id],
+          exportConditions,
+          // pass-through of the rest of the context
           packageInfoCache,
           extensions,
           mainFields,
@@ -797,11 +806,22 @@ async function resolveWithExportMap({
           useBrowserOverrides,
           baseDir,
           moduleDirectories,
-          modulePaths
+          modulePaths,
+          rootDir,
+          ignoreSideEffectsForRoot,
+          allowExportsFolderMapping
         });
       }
     });
 
+    if (resolveResult == null) {
+      // When the target of an "imports" mapping cannot be resolved,
+      // surface a proper resolve error instead of throwing from
+      // fileURLToPath(null).
+      throw new ResolveError(
+        `Could not resolve import "${importSpecifier}" in ${importer} using imports.`
+      );
+    }
     const location = url.fileURLToPath(resolveResult);
     return {
       location: preserveSymlinks ? location : await resolveSymlink(location),
@@ -1167,7 +1187,7 @@ function nodeResolve(opts = {}) {
 
     const importSpecifierList = [importee];
 
-    if (importer === undefined && !importee[0].match(/^\.?\.?\//)) {
+    if (importer === undefined && importee[0] && !importee[0].match(/^\.?\.?\//)) {
       // For module graph roots (i.e. when importer is undefined), we
       // need to handle 'path fragments` like `foo/bar` that are commonly
       // found in rollup config files. If importee doesn't look like a

node_modules/@rollup/plugin-node-resolve/dist/es/index.js

@@ -8,7 +8,7 @@ import { pathToFileURL, fileURLToPath } from 'url';
 import resolve$1 from 'resolve';
 import { createFilter } from '@rollup/pluginutils';
 
-var version = "16.0.1";
+var version = "16.0.3";
 var peerDependencies = {
 	rollup: "^2.78.0||^3.0.0||^4.0.0"
 };
@@ -783,9 +783,18 @@ async function resolveWithExportMap({
       importer,
       moduleDirs: moduleDirectories,
       conditions: exportConditions,
+      // Resolve targets of "imports" mappings using the same algorithm
+      // we use for normal specifiers: try export maps first and then
+      // fall back to classic resolution. This is important for cases
+      // like "#foo/*": "@scope/pkg/*" where the target package relies
+      // on "exports" to expose subpaths. Using the classic resolver
+      // alone would fail to find those subpaths.
       resolveId(id /* , parent*/) {
-        return resolveIdClassic({
-          importSpecifier: id,
+        return resolveImportSpecifiers({
+          importer,
+          importSpecifierList: [id],
+          exportConditions,
+          // pass-through of the rest of the context
           packageInfoCache,
           extensions,
           mainFields,
@@ -793,11 +802,22 @@ async function resolveWithExportMap({
           useBrowserOverrides,
           baseDir,
           moduleDirectories,
-          modulePaths
+          modulePaths,
+          rootDir,
+          ignoreSideEffectsForRoot,
+          allowExportsFolderMapping
         });
       }
     });
 
+    if (resolveResult == null) {
+      // When the target of an "imports" mapping cannot be resolved,
+      // surface a proper resolve error instead of throwing from
+      // fileURLToPath(null).
+      throw new ResolveError(
+        `Could not resolve import "${importSpecifier}" in ${importer} using imports.`
+      );
+    }
     const location = fileURLToPath(resolveResult);
     return {
       location: preserveSymlinks ? location : await resolveSymlink(location),
@@ -1163,7 +1183,7 @@ function nodeResolve(opts = {}) {
 
     const importSpecifierList = [importee];
 
-    if (importer === undefined && !importee[0].match(/^\.?\.?\//)) {
+    if (importer === undefined && importee[0] && !importee[0].match(/^\.?\.?\//)) {
       // For module graph roots (i.e. when importer is undefined), we
       // need to handle 'path fragments` like `foo/bar` that are commonly
       // found in rollup config files. If importee doesn't look like a

node_modules/@rollup/plugin-node-resolve/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rollup/plugin-node-resolve",
-  "version": "16.0.1",
+  "version": "16.0.3",
   "publishConfig": {
     "access": "public"
   },

node_modules/@rollup/plugin-typescript/README.md

@@ -77,7 +77,11 @@ A [picomatch pattern](https://github.com/micromatch/picomatch), or array of patt
 Type: `String` | `Array[...String]`<br>
 Default: `null`
 
-A [picomatch pattern](https://github.com/micromatch/picomatch), or array of patterns, which specifies the files in the build the plugin should operate on. By default all `.ts` and `.tsx` files are targeted.
+A [picomatch pattern](https://github.com/micromatch/picomatch), or array of patterns, which specifies the files in the build the plugin should operate on. By default all `.ts` and `.tsx` files are targeted. If your `tsconfig.json` (or plugin `compilerOptions`) sets `allowJs: true`, the default include expands to also cover `.js`, `.jsx`, `.mjs`, and `.cjs` files so that JavaScript sources are downleveled by TypeScript as well.
+
+> Note: When `allowJs` is enabled and no `outDir` is configured, this plugin creates a temporary output directory for TypeScript emit to avoid TS5055 (overwriting input files). The effective `outDir` (whether user-provided or the temporary one) is excluded from plugin processing to prevent re-processing emitted files. The temporary directory is removed after a non-watch build completes; in watch mode it is removed when the watcher stops.
+>
+> When `allowJs` expands the default include and you have not specified patterns via `include`/`exclude`, the plugin also excludes `**/node_modules/**` by default to avoid transforming third-party code.
 
 ### `filterRoot`
 
@@ -138,15 +142,20 @@ Supported transformer factories:
 
 - all **built-in** TypeScript custom transformer factories:
 
-  - `import('typescript').TransformerFactory` annotated **TransformerFactory** bellow
-  - `import('typescript').CustomTransformerFactory` annotated **CustomTransformerFactory** bellow
+  - `import('typescript').TransformerFactory` annotated **TransformerFactory** below
+  - `import('typescript').CustomTransformerFactory` annotated **CustomTransformerFactory** below
 
 - **ProgramTransformerFactory** represents a transformer factory allowing the resulting transformer to grab a reference to the **Program** instance
 
   ```js
   {
     type: 'program',
-    factory: (program: Program) => TransformerFactory | CustomTransformerFactory
+    // An optional `getProgram` getter is provided in all modes. In non‑watch it returns
+    // the same Program as the first argument. In watch mode, when the
+    // `recreateTransformersOnRebuild` option is enabled, the getter reflects the latest
+    // Program across rebuilds; otherwise it refers to the initial Program.
+    factory: (program: Program, getProgram?: () => Program) =>
+      TransformerFactory | CustomTransformerFactory
   }
   ```
 
@@ -163,16 +172,24 @@ typescript({
   transformers: {
     before: [
       {
-        // Allow the transformer to get a Program reference in it's factory
+        // Allow the transformer to get a Program reference in its factory.
+        // Prefer deferring `getProgram()` usage to transformation time so watch
+        // mode can see the freshest Program when `recreateTransformersOnRebuild`
+        // is enabled.
         type: 'program',
-        factory: (program) => {
-          return ProgramRequiringTransformerFactory(program);
+        factory: (program, getProgram) => {
+          const get = getProgram ?? (() => program);
+          return (context) => (source) => {
+            const latest = get();
+            // use `latest` here
+            return ts.visitEachChild(source, (n) => n, context);
+          };
         }
       },
       {
         type: 'typeChecker',
         factory: (typeChecker) => {
-          // Allow the transformer to get a TypeChecker reference in it's factory
+          // Allow the transformer to get a TypeChecker reference in its factory
           return TypeCheckerRequiringTransformerFactory(typeChecker);
         }
       }
@@ -205,8 +222,8 @@ Supported transformer factories:
 
 - all **built-in** TypeScript custom transformer factories:
 
-  - `import('typescript').TransformerFactory` annotated **TransformerFactory** bellow
-  - `import('typescript').CustomTransformerFactory` annotated **CustomTransformerFactory** bellow
+  - `import('typescript').TransformerFactory` annotated **TransformerFactory** below
+  - `import('typescript').CustomTransformerFactory` annotated **CustomTransformerFactory** below
 
 The example above could be written like this:
 
@@ -241,6 +258,34 @@ typescript({
 });
 ```
 
+Note on watch mode
+
+By default (legacy behavior), this plugin reuses the same custom transformer factories for the lifetime of a watch session. Advanced users can opt into recreating factories on every TypeScript rebuild by enabling the `recreateTransformersOnRebuild` option. When enabled, both `program`- and `typeChecker`-based factories are rebuilt per watch cycle, and `getProgram()` (when used) reflects the latest Program across rebuilds.
+
+### `recreateTransformersOnRebuild`
+
+Type: `Boolean`<br>
+Default: `false` (legacy behavior)
+
+When `true`, the plugin recreates custom transformer factories on each TypeScript watch rebuild. This ensures factories capture the current `Program`/`TypeChecker` per cycle and that the optional `getProgram()` getter provided to `program`-based factories reflects the latest `Program` across rebuilds. Most users do not need this; enable it if your transformers depend on up‑to‑date Program/TypeChecker identities.
+
+```js
+// Opt-in to per-rebuild transformer recreation in watch mode
+typescript({
+  recreateTransformersOnRebuild: true,
+  transformers: {
+    before: [
+      {
+        type: 'program',
+        factory(program, getProgram) {
+          /* ... */
+        }
+      }
+    ]
+  }
+});
+```
+
 ### `cacheDir`
 
 Type: `String`<br>

node_modules/@rollup/plugin-typescript/dist/cjs/index.js

@@ -3,11 +3,12 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var path = require('path');
+var fs = require('fs');
+var os = require('os');
 var pluginutils = require('@rollup/pluginutils');
 var typescript$1 = require('typescript');
 var url = require('url');
 var resolve = require('resolve');
-var fs = require('fs');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopNamespaceDefault(e) {
@@ -28,6 +29,8 @@ function _interopNamespaceDefault(e) {
 }
 
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var os__namespace = /*#__PURE__*/_interopNamespaceDefault(os);
 
 /**
  * Create a format diagnostics host to use with the Typescript type checking APIs.
@@ -119,7 +122,7 @@ const getTsLibPath = () => {
  * - `tslib`: ESM code from the tslib helper library (possibly custom).
  */
 const getPluginOptions = (options) => {
-    const { cacheDir, exclude, include, filterRoot, noForceEmit, transformers, tsconfig, tslib, typescript, outputToFilesystem, compilerOptions, 
+    const { cacheDir, exclude, include, filterRoot, noForceEmit, transformers, recreateTransformersOnRebuild, tsconfig, tslib, typescript, outputToFilesystem, compilerOptions, 
     // previously was compilerOptions
     ...extra } = options;
     return {
@@ -133,6 +136,8 @@ const getPluginOptions = (options) => {
         typescript: typescript || typescript$1,
         tslib: tslib || getTsLibPath(),
         transformers,
+        // Only enable when explicitly set to true to avoid truthy string pitfalls in JS configs
+        recreateTransformersOnRebuild: recreateTransformersOnRebuild === true,
         outputToFilesystem
     };
 };
@@ -612,18 +617,19 @@ function mergeTransformers(builder, ...input) {
                 }
                 if ('type' in transformer) {
                     if (typeof transformer.factory === 'function') {
-                        // Allow custom factories to grab the extra information required
-                        program = program || builder.getProgram();
-                        typeChecker = typeChecker || program.getTypeChecker();
                         let factory;
                         if (transformer.type === 'program') {
-                            program = program || builder.getProgram();
-                            factory = transformer.factory(program);
+                            const currentProgram = program !== null && program !== void 0 ? program : builder.getProgram();
+                            // Pass a getter so transformers can access the latest Program in watch mode
+                            factory = transformer.factory(currentProgram, () => builder.getProgram());
+                            program = currentProgram;
                         }
                         else {
-                            program = program || builder.getProgram();
-                            typeChecker = typeChecker || program.getTypeChecker();
-                            factory = transformer.factory(typeChecker);
+                            const currentProgram = program !== null && program !== void 0 ? program : builder.getProgram();
+                            const currentTypeChecker = typeChecker !== null && typeChecker !== void 0 ? typeChecker : currentProgram.getTypeChecker();
+                            factory = transformer.factory(currentTypeChecker);
+                            program = currentProgram;
+                            typeChecker = currentTypeChecker;
                         }
                         // Forward the requested reference to the custom transformer factory
                         if (factory) {
@@ -725,7 +731,7 @@ class WatchProgramHelper {
  * with an API for reading files, checking directories and case sensitivity etc.
  * @see https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API
  */
-function createWatchHost(ts, context, { formatHost, parsedOptions, writeFile, status, resolveModule, transformers }) {
+function createWatchHost(ts, context, { formatHost, parsedOptions, writeFile, status, resolveModule, transformers, recreateTransformersOnRebuild }) {
     const createProgram = ts.createEmitAndSemanticDiagnosticsBuilderProgram;
     const baseHost = ts.createWatchCompilerHost(parsedOptions.fileNames, parsedOptions.options, ts.sys, createProgram, buildDiagnosticReporter(ts, context, formatHost), status, parsedOptions.projectReferences);
     let createdTransformers;
@@ -733,6 +739,13 @@ function createWatchHost(ts, context, { formatHost, parsedOptions, writeFile, st
         ...baseHost,
         /** Override the created program so an in-memory emit is used */
         afterProgramCreate(program) {
+            // Optionally recompute custom transformers for each new builder program in watch mode
+            // so factories capture the current Program/TypeChecker and any provided getters can
+            // return the latest values. When disabled (default), legacy behavior reuses the
+            // same factories across rebuilds.
+            if (recreateTransformersOnRebuild) {
+                createdTransformers = void 0;
+            }
             const origEmit = program.emit;
             // eslint-disable-next-line no-param-reassign
             program.emit = (targetSourceFile, _, cancellationToken, emitOnlyDtsFiles, customTransformers) => {
@@ -793,13 +806,104 @@ class TSCache {
 }
 
 function typescript(options = {}) {
-    const { cacheDir, compilerOptions, exclude, filterRoot, include, outputToFilesystem, noForceEmit, transformers, tsconfig, tslib, typescript: ts } = getPluginOptions(options);
+    const { cacheDir, compilerOptions, exclude, filterRoot, include, outputToFilesystem, noForceEmit, transformers, recreateTransformersOnRebuild, tsconfig, tslib, typescript: ts } = getPluginOptions(options);
     const tsCache = new TSCache(cacheDir);
     const emittedFiles = new Map();
     const watchProgramHelper = new WatchProgramHelper();
+    let autoOutDir = null;
+    // Centralize temp outDir cleanup to avoid duplication/drift across hooks
+    const cleanupAutoOutDir = () => {
+        if (!autoOutDir)
+            return;
+        try {
+            fs__namespace.rmSync(autoOutDir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore cleanup failures
+        }
+        autoOutDir = null;
+    };
+    // Ensure the TypeScript watch program is closed and temp outDir is cleaned
+    // even if closing throws. Call this from lifecycle hooks that need teardown.
+    const closeProgramAndCleanup = () => {
+        try {
+            // ESLint doesn't understand optional chaining
+            // eslint-disable-next-line
+            program === null || program === void 0 ? void 0 : program.close();
+        }
+        finally {
+            cleanupAutoOutDir();
+        }
+    };
     const parsedOptions = parseTypescriptConfig(ts, tsconfig, compilerOptions, noForceEmit);
-    const filter = pluginutils.createFilter(include || '{,**/}*.(cts|mts|ts|tsx)', exclude, {
-        resolve: filterRoot !== null && filterRoot !== void 0 ? filterRoot : parsedOptions.options.rootDir
+    // When processing JS via allowJs, redirect emit output away from source files
+    // to avoid TS5055 (cannot write file because it would overwrite input file).
+    // We only set a temp outDir if the user did not configure one.
+    if (parsedOptions.options.allowJs && !parsedOptions.options.outDir) {
+        // Create a unique temporary outDir to avoid TS5055 when emitting JS
+        autoOutDir = fs__namespace.mkdtempSync(path__namespace.join(os__namespace.tmpdir(), 'rollup-plugin-typescript-allowjs-'));
+        parsedOptions.options.outDir = autoOutDir;
+    }
+    // Determine default include pattern. By default we only process TS files.
+    // When the consumer enables `allowJs` in their tsconfig/compiler options,
+    // also include common JS extensions so modern JS syntax in .js files is
+    // downleveled by TypeScript as expected.
+    const defaultInclude = parsedOptions.options.allowJs
+        ? '{,**/}*.{cts,mts,ts,tsx,js,jsx,mjs,cjs}'
+        : '{,**/}*.{cts,mts,ts,tsx}';
+    // Build filter exclusions, ensuring we never re-process TypeScript emit outputs.
+    // Always exclude the effective outDir (user-provided or the auto-created temp dir).
+    const filterExclude = Array.isArray(exclude) ? [...exclude] : exclude ? [exclude] : [];
+    // When auto-expanding to include JS (allowJs) and the user did not provide
+    // custom include/exclude patterns, avoid transforming third-party code by
+    // default by excluding node_modules.
+    if (parsedOptions.options.allowJs && !include && !exclude) {
+        filterExclude.push('**/node_modules/**');
+    }
+    const effectiveOutDir = parsedOptions.options.outDir
+        ? path__namespace.resolve(parsedOptions.options.outDir)
+        : null;
+    // Determine the base used for containment checks. If pattern resolution is disabled
+    // (filterRoot === false), fall back to process.cwd() so we don't accidentally
+    // exclude sources when e.g. outDir='.'.
+    const willResolvePatterns = filterRoot !== false;
+    // Only treat string values of `filterRoot` as a base directory; booleans (e.g., true)
+    // should not flow into path resolution. Fallback to the tsconfig `rootDir` when not set.
+    const configuredBase = willResolvePatterns
+        ? typeof filterRoot === 'string'
+            ? filterRoot
+            : parsedOptions.options.rootDir
+        : null;
+    const filterBaseAbs = configuredBase ? path__namespace.resolve(configuredBase) : null;
+    if (effectiveOutDir) {
+        // Avoid excluding sources: skip when the filter base (or cwd fallback) lives inside outDir.
+        // Use path.relative with root equality guard for cross-platform correctness.
+        const baseForContainment = filterBaseAbs !== null && filterBaseAbs !== void 0 ? filterBaseAbs : process.cwd();
+        const outDirContainsFilterBase = (() => {
+            // Different roots (e.g., drive letters on Windows) cannot be in a parent/child relationship.
+            // Normalize Windows drive-letter case before comparison to avoid false mismatches.
+            const getRoot = (p) => {
+                const r = path__namespace.parse(p).root;
+                return process.platform === 'win32' ? r.toLowerCase() : r;
+            };
+            if (getRoot(effectiveOutDir) !== getRoot(baseForContainment))
+                return false;
+            const rel = path__namespace.relative(effectiveOutDir, baseForContainment);
+            // rel === '' -> same dir; absolute or '..' => outside
+            return rel === '' || (!rel.startsWith('..') && !path__namespace.isAbsolute(rel));
+        })();
+        if (!outDirContainsFilterBase) {
+            filterExclude.push(normalizePath(path__namespace.join(effectiveOutDir, '**')));
+        }
+    }
+    const filter = pluginutils.createFilter(include || defaultInclude, filterExclude, {
+        // Guard against non-string truthy values (e.g., boolean true). Only strings are valid
+        // for `resolve`; `false` disables resolution. Otherwise, fall back to `rootDir`.
+        resolve: typeof filterRoot === 'string'
+            ? filterRoot
+            : filterRoot === false
+                ? false
+                : parsedOptions.options.rootDir || process.cwd()
     });
     parsedOptions.fileNames = parsedOptions.fileNames.filter(filter);
     const formatHost = createFormattingHost(ts, parsedOptions.options);
@@ -837,7 +941,8 @@ function typescript(options = {}) {
                     status(diagnostic) {
                         watchProgramHelper.handleStatus(diagnostic);
                     },
-                    transformers
+                    transformers,
+                    recreateTransformersOnRebuild
                 });
             }
         },
@@ -848,11 +953,13 @@ function typescript(options = {}) {
         },
         buildEnd() {
             if (this.meta.watchMode !== true) {
-                // ESLint doesn't understand optional chaining
-                // eslint-disable-next-line
-                program === null || program === void 0 ? void 0 : program.close();
+                closeProgramAndCleanup();
             }
         },
+        // Ensure program is closed and temp outDir is removed exactly once when watch stops
+        closeWatcher() {
+            closeProgramAndCleanup();
+        },
         renderStart(outputOptions) {
             validateSourceMap(this, parsedOptions.options, outputOptions, parsedOptions.autoSetSourceMap);
             validatePaths(this, parsedOptions.options, outputOptions);

node_modules/@rollup/plugin-typescript/dist/es/index.js

@@ -1,10 +1,12 @@
 import * as path from 'path';
 import path__default, { resolve as resolve$1, dirname, relative } from 'path';
+import * as fs from 'fs';
+import fs__default, { readFileSync, promises } from 'fs';
+import * as os from 'os';
 import { createFilter } from '@rollup/pluginutils';
 import typescript$1 from 'typescript';
 import { fileURLToPath } from 'url';
 import resolve from 'resolve';
-import fs, { readFileSync, promises } from 'fs';
 
 /**
  * Create a format diagnostics host to use with the Typescript type checking APIs.
@@ -96,7 +98,7 @@ const getTsLibPath = () => {
  * - `tslib`: ESM code from the tslib helper library (possibly custom).
  */
 const getPluginOptions = (options) => {
-    const { cacheDir, exclude, include, filterRoot, noForceEmit, transformers, tsconfig, tslib, typescript, outputToFilesystem, compilerOptions, 
+    const { cacheDir, exclude, include, filterRoot, noForceEmit, transformers, recreateTransformersOnRebuild, tsconfig, tslib, typescript, outputToFilesystem, compilerOptions, 
     // previously was compilerOptions
     ...extra } = options;
     return {
@@ -110,6 +112,8 @@ const getPluginOptions = (options) => {
         typescript: typescript || typescript$1,
         tslib: tslib || getTsLibPath(),
         transformers,
+        // Only enable when explicitly set to true to avoid truthy string pitfalls in JS configs
+        recreateTransformersOnRebuild: recreateTransformersOnRebuild === true,
         outputToFilesystem
     };
 };
@@ -589,18 +593,19 @@ function mergeTransformers(builder, ...input) {
                 }
                 if ('type' in transformer) {
                     if (typeof transformer.factory === 'function') {
-                        // Allow custom factories to grab the extra information required
-                        program = program || builder.getProgram();
-                        typeChecker = typeChecker || program.getTypeChecker();
                         let factory;
                         if (transformer.type === 'program') {
-                            program = program || builder.getProgram();
-                            factory = transformer.factory(program);
+                            const currentProgram = program !== null && program !== void 0 ? program : builder.getProgram();
+                            // Pass a getter so transformers can access the latest Program in watch mode
+                            factory = transformer.factory(currentProgram, () => builder.getProgram());
+                            program = currentProgram;
                         }
                         else {
-                            program = program || builder.getProgram();
-                            typeChecker = typeChecker || program.getTypeChecker();
-                            factory = transformer.factory(typeChecker);
+                            const currentProgram = program !== null && program !== void 0 ? program : builder.getProgram();
+                            const currentTypeChecker = typeChecker !== null && typeChecker !== void 0 ? typeChecker : currentProgram.getTypeChecker();
+                            factory = transformer.factory(currentTypeChecker);
+                            program = currentProgram;
+                            typeChecker = currentTypeChecker;
                         }
                         // Forward the requested reference to the custom transformer factory
                         if (factory) {
@@ -702,7 +707,7 @@ class WatchProgramHelper {
  * with an API for reading files, checking directories and case sensitivity etc.
  * @see https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API
  */
-function createWatchHost(ts, context, { formatHost, parsedOptions, writeFile, status, resolveModule, transformers }) {
+function createWatchHost(ts, context, { formatHost, parsedOptions, writeFile, status, resolveModule, transformers, recreateTransformersOnRebuild }) {
     const createProgram = ts.createEmitAndSemanticDiagnosticsBuilderProgram;
     const baseHost = ts.createWatchCompilerHost(parsedOptions.fileNames, parsedOptions.options, ts.sys, createProgram, buildDiagnosticReporter(ts, context, formatHost), status, parsedOptions.projectReferences);
     let createdTransformers;
@@ -710,6 +715,13 @@ function createWatchHost(ts, context, { formatHost, parsedOptions, writeFile, st
         ...baseHost,
         /** Override the created program so an in-memory emit is used */
         afterProgramCreate(program) {
+            // Optionally recompute custom transformers for each new builder program in watch mode
+            // so factories capture the current Program/TypeChecker and any provided getters can
+            // return the latest values. When disabled (default), legacy behavior reuses the
+            // same factories across rebuilds.
+            if (recreateTransformersOnRebuild) {
+                createdTransformers = void 0;
+            }
             const origEmit = program.emit;
             // eslint-disable-next-line no-param-reassign
             program.emit = (targetSourceFile, _, cancellationToken, emitOnlyDtsFiles, customTransformers) => {
@@ -739,7 +751,7 @@ function createWatchProgram(ts, context, options) {
 /** Creates the folders needed given a path to a file to be saved*/
 const createFileFolder = (filePath) => {
     const folderPath = path__default.dirname(filePath);
-    fs.mkdirSync(folderPath, { recursive: true });
+    fs__default.mkdirSync(folderPath, { recursive: true });
 };
 class TSCache {
     constructor(cacheFolder = '.rollup.cache') {
@@ -753,30 +765,121 @@ class TSCache {
     cacheCode(fileName, code) {
         const cachedPath = this.cachedFilename(fileName);
         createFileFolder(cachedPath);
-        fs.writeFileSync(cachedPath, code);
+        fs__default.writeFileSync(cachedPath, code);
     }
     /** Checks if a file is in the cache */
     isCached(fileName) {
-        return fs.existsSync(this.cachedFilename(fileName));
+        return fs__default.existsSync(this.cachedFilename(fileName));
     }
     /** Read a file from the cache given the output name*/
     getCached(fileName) {
         let code;
         if (this.isCached(fileName)) {
-            code = fs.readFileSync(this.cachedFilename(fileName), { encoding: 'utf-8' });
+            code = fs__default.readFileSync(this.cachedFilename(fileName), { encoding: 'utf-8' });
         }
         return code;
     }
 }
 
 function typescript(options = {}) {
-    const { cacheDir, compilerOptions, exclude, filterRoot, include, outputToFilesystem, noForceEmit, transformers, tsconfig, tslib, typescript: ts } = getPluginOptions(options);
+    const { cacheDir, compilerOptions, exclude, filterRoot, include, outputToFilesystem, noForceEmit, transformers, recreateTransformersOnRebuild, tsconfig, tslib, typescript: ts } = getPluginOptions(options);
     const tsCache = new TSCache(cacheDir);
     const emittedFiles = new Map();
     const watchProgramHelper = new WatchProgramHelper();
+    let autoOutDir = null;
+    // Centralize temp outDir cleanup to avoid duplication/drift across hooks
+    const cleanupAutoOutDir = () => {
+        if (!autoOutDir)
+            return;
+        try {
+            fs.rmSync(autoOutDir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore cleanup failures
+        }
+        autoOutDir = null;
+    };
+    // Ensure the TypeScript watch program is closed and temp outDir is cleaned
+    // even if closing throws. Call this from lifecycle hooks that need teardown.
+    const closeProgramAndCleanup = () => {
+        try {
+            // ESLint doesn't understand optional chaining
+            // eslint-disable-next-line
+            program === null || program === void 0 ? void 0 : program.close();
+        }
+        finally {
+            cleanupAutoOutDir();
+        }
+    };
     const parsedOptions = parseTypescriptConfig(ts, tsconfig, compilerOptions, noForceEmit);
-    const filter = createFilter(include || '{,**/}*.(cts|mts|ts|tsx)', exclude, {
-        resolve: filterRoot !== null && filterRoot !== void 0 ? filterRoot : parsedOptions.options.rootDir
+    // When processing JS via allowJs, redirect emit output away from source files
+    // to avoid TS5055 (cannot write file because it would overwrite input file).
+    // We only set a temp outDir if the user did not configure one.
+    if (parsedOptions.options.allowJs && !parsedOptions.options.outDir) {
+        // Create a unique temporary outDir to avoid TS5055 when emitting JS
+        autoOutDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rollup-plugin-typescript-allowjs-'));
+        parsedOptions.options.outDir = autoOutDir;
+    }
+    // Determine default include pattern. By default we only process TS files.
+    // When the consumer enables `allowJs` in their tsconfig/compiler options,
+    // also include common JS extensions so modern JS syntax in .js files is
+    // downleveled by TypeScript as expected.
+    const defaultInclude = parsedOptions.options.allowJs
+        ? '{,**/}*.{cts,mts,ts,tsx,js,jsx,mjs,cjs}'
+        : '{,**/}*.{cts,mts,ts,tsx}';
+    // Build filter exclusions, ensuring we never re-process TypeScript emit outputs.
+    // Always exclude the effective outDir (user-provided or the auto-created temp dir).
+    const filterExclude = Array.isArray(exclude) ? [...exclude] : exclude ? [exclude] : [];
+    // When auto-expanding to include JS (allowJs) and the user did not provide
+    // custom include/exclude patterns, avoid transforming third-party code by
+    // default by excluding node_modules.
+    if (parsedOptions.options.allowJs && !include && !exclude) {
+        filterExclude.push('**/node_modules/**');
+    }
+    const effectiveOutDir = parsedOptions.options.outDir
+        ? path.resolve(parsedOptions.options.outDir)
+        : null;
+    // Determine the base used for containment checks. If pattern resolution is disabled
+    // (filterRoot === false), fall back to process.cwd() so we don't accidentally
+    // exclude sources when e.g. outDir='.'.
+    const willResolvePatterns = filterRoot !== false;
+    // Only treat string values of `filterRoot` as a base directory; booleans (e.g., true)
+    // should not flow into path resolution. Fallback to the tsconfig `rootDir` when not set.
+    const configuredBase = willResolvePatterns
+        ? typeof filterRoot === 'string'
+            ? filterRoot
+            : parsedOptions.options.rootDir
+        : null;
+    const filterBaseAbs = configuredBase ? path.resolve(configuredBase) : null;
+    if (effectiveOutDir) {
+        // Avoid excluding sources: skip when the filter base (or cwd fallback) lives inside outDir.
+        // Use path.relative with root equality guard for cross-platform correctness.
+        const baseForContainment = filterBaseAbs !== null && filterBaseAbs !== void 0 ? filterBaseAbs : process.cwd();
+        const outDirContainsFilterBase = (() => {
+            // Different roots (e.g., drive letters on Windows) cannot be in a parent/child relationship.
+            // Normalize Windows drive-letter case before comparison to avoid false mismatches.
+            const getRoot = (p) => {
+                const r = path.parse(p).root;
+                return process.platform === 'win32' ? r.toLowerCase() : r;
+            };
+            if (getRoot(effectiveOutDir) !== getRoot(baseForContainment))
+                return false;
+            const rel = path.relative(effectiveOutDir, baseForContainment);
+            // rel === '' -> same dir; absolute or '..' => outside
+            return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+        })();
+        if (!outDirContainsFilterBase) {
+            filterExclude.push(normalizePath(path.join(effectiveOutDir, '**')));
+        }
+    }
+    const filter = createFilter(include || defaultInclude, filterExclude, {
+        // Guard against non-string truthy values (e.g., boolean true). Only strings are valid
+        // for `resolve`; `false` disables resolution. Otherwise, fall back to `rootDir`.
+        resolve: typeof filterRoot === 'string'
+            ? filterRoot
+            : filterRoot === false
+                ? false
+                : parsedOptions.options.rootDir || process.cwd()
     });
     parsedOptions.fileNames = parsedOptions.fileNames.filter(filter);
     const formatHost = createFormattingHost(ts, parsedOptions.options);
@@ -814,7 +917,8 @@ function typescript(options = {}) {
                     status(diagnostic) {
                         watchProgramHelper.handleStatus(diagnostic);
                     },
-                    transformers
+                    transformers,
+                    recreateTransformersOnRebuild
                 });
             }
         },
@@ -825,11 +929,13 @@ function typescript(options = {}) {
         },
         buildEnd() {
             if (this.meta.watchMode !== true) {
-                // ESLint doesn't understand optional chaining
-                // eslint-disable-next-line
-                program === null || program === void 0 ? void 0 : program.close();
+                closeProgramAndCleanup();
             }
         },
+        // Ensure program is closed and temp outDir is removed exactly once when watch stops
+        closeWatcher() {
+            closeProgramAndCleanup();
+        },
         renderStart(outputOptions) {
             validateSourceMap(this, parsedOptions.options, outputOptions, parsedOptions.autoSetSourceMap);
             validatePaths(this, parsedOptions.options, outputOptions);

node_modules/@rollup/plugin-typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rollup/plugin-typescript",
-  "version": "12.1.4",
+  "version": "12.3.0",
   "publishConfig": {
     "access": "public"
   },

node_modules/@rollup/plugin-typescript/types/index.d.ts

@@ -28,7 +28,18 @@ export type CustomTransformerFactories = {
 interface ProgramTransformerFactory<T extends TransformerStage> {
   type: 'program';
 
-  factory(program: Program): StagedTransformerFactory<T>;
+  /**
+   * Factory receives the current Program and may also receive a getter for retrieving
+   * the Program at call time. The getter may be provided in all modes. In non-watch it
+   * returns the same Program as the first argument. In watch mode:
+   *  - When `recreateTransformersOnRebuild` is enabled (plugin option), the getter
+   *    reflects the latest Program across rebuilds.
+   *  - When disabled (default, legacy behavior), factories are reused and the getter
+   *    refers to the initial Program from when the factory was created.
+   * The second parameter remains optional for backwards compatibility with existing
+   * transformer factories.
+   */
+  factory(program: Program, getProgram?: () => Program): StagedTransformerFactory<T>;
 }
 
 interface TypeCheckerTransformerFactory<T extends TransformerStage> {
@@ -89,6 +100,14 @@ export interface RollupTypescriptPluginOptions {
    * Override force setting of `noEmit` and `emitDeclarationOnly` and use what is defined in `tsconfig.json`
    */
   noForceEmit?: boolean;
+  /**
+   * Advanced: when true, recreate custom transformer factories on each TypeScript
+   * watch rebuild so that `program`/`typeChecker`-based factories are rebuilt and
+   * `getProgram()` (when used) reflects the latest Program across rebuilds.
+   * Defaults to false (legacy behavior), which reuses factories for the lifetime
+   * of the watch session.
+   */
+  recreateTransformersOnRebuild?: boolean;
 }
 
 export interface FlexibleCompilerOptions extends CompilerOptions {

node_modules/@rollup/rollup-linux-x64-gnu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rollup/rollup-linux-x64-gnu",
-  "version": "4.50.2",
+  "version": "4.52.5",
   "os": [
     "linux"
   ],
@@ -14,7 +14,10 @@
   "author": "Lukas Taegert-Atkinson",
   "homepage": "https://rollupjs.org/",
   "license": "MIT",
-  "repository": "rollup/rollup",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rollup/rollup.git"
+  },
   "libc": [
     "glibc"
   ],

node_modules/@rollup/rollup-linux-x64-musl/README.md

@@ -1,3 +0,0 @@
-# `@rollup/rollup-linux-x64-musl`
-
-This is the **x86_64-unknown-linux-musl** binary for `rollup`

node_modules/@rollup/rollup-linux-x64-musl/package.json

@@ -1,22 +0,0 @@
-{
-  "name": "@rollup/rollup-linux-x64-musl",
-  "version": "4.50.2",
-  "os": [
-    "linux"
-  ],
-  "cpu": [
-    "x64"
-  ],
-  "files": [
-    "rollup.linux-x64-musl.node"
-  ],
-  "description": "Native bindings for Rollup",
-  "author": "Lukas Taegert-Atkinson",
-  "homepage": "https://rollupjs.org/",
-  "license": "MIT",
-  "repository": "rollup/rollup",
-  "libc": [
-    "musl"
-  ],
-  "main": "./rollup.linux-x64-musl.node"
-}

node_modules/@rollup/rollup-win32-x64-msvc/README.md

@@ -1,3 +0,0 @@
-# `@rollup/rollup-win32-x64-msvc`
-
-This is the **x86_64-pc-windows-msvc** binary for `rollup`

node_modules/@rollup/rollup-win32-x64-msvc/package.json

@@ -1,19 +0,0 @@
-{
-  "name": "@rollup/rollup-win32-x64-msvc",
-  "version": "4.50.2",
-  "os": [
-    "win32"
-  ],
-  "cpu": [
-    "x64"
-  ],
-  "files": [
-    "rollup.win32-x64-msvc.node"
-  ],
-  "description": "Native bindings for Rollup",
-  "author": "Lukas Taegert-Atkinson",
-  "homepage": "https://rollupjs.org/",
-  "license": "MIT",
-  "repository": "rollup/rollup",
-  "main": "./rollup.win32-x64-msvc.node"
-}