diff --git a/gulpfile.js/index.js b/gulpfile.js/index.js
index 3cf6f3427e..961ea91419 100644
--- a/gulpfile.js/index.js
+++ b/gulpfile.js/index.js
@@ -533,8 +533,8 @@ function _computeCacheManifest(baseDir, filePaths) {
 
     totalSize = Math.round(totalSize/1024); // KB
     console.log("Total size of cache in KB: ", totalSize);
-    if(totalSize > 75000){
-        throw new Error("The total size of the src or dist folder core assets exceeds 75MB." +
+    if(totalSize > 78000){
+        throw new Error("The total size of the src or dist folder core assets exceeds 78MB." +
             "\nPlease review and trim storage. This significantly impacts the distribution size." +
             "\nEither trim down the size or increase the limit after careful review.");
     }
@@ -909,7 +909,8 @@ function _renameExtensionConcatAsExtensionJSInDist(extensionName) {
 }
 
 const minifyableExtensions = ["CloseOthers", "CodeFolding", "DebugCommands", "Git",
-    "HealthData", "JavaScriptCodeHints", "JavaScriptRefactoring", "QuickView", "TypeScriptSupport"];
+    "HealthData", "JavaScriptCodeHints", "JavaScriptRefactoring", "PHPSupport", "QuickView",
+    "TypeScriptSupport"];
 // extensions that nned not be minified either coz they are single file extensions or some other reason.
 const nonMinifyExtensions = ["CSSAtRuleCodeHints", "CSSCodeHints",
     "CSSPseudoSelectorHints", "DarkTheme", "DocCommentHints", "HandlebarsSupport", "HTMLCodeHints",
diff --git a/src-node/lsp-client.js b/src-node/lsp-client.js
index 423167df03..0bbfd0bdce 100644
--- a/src-node/lsp-client.js
+++ b/src-node/lsp-client.js
@@ -218,15 +218,27 @@ exports.startServer = async function startServer(params) {
         return { success: true, message: "already running", serverId };
     }
 
-    // Prefer a server bundled in node_modules/.bin, otherwise fall back to PATH.
+    // Command resolution, in order:
+    // 1. An absolute path to a .js entry (e.g. a user-installed server like intelephense living
+    //    outside src-node) runs on our own node runtime - process.execPath is phnode itself, the
+    //    same spawn-self pattern _npmInstallInFolder and the ESLint service use. This sidesteps
+    //    node_modules/.bin shims entirely (they are sh scripts / .cmd on Windows).
+    // 2. A server bundled in src-node/node_modules/.bin.
+    // 3. Fall back to PATH.
     let commandPath = command;
-    const localBinPath = path.join(NODE_MODULES_BIN, command);
-    if (fs.existsSync(localBinPath)) {
-        commandPath = localBinPath;
+    let spawnArgs = args;
+    if (path.isAbsolute(command) && command.endsWith('.js')) {
+        spawnArgs = [command, ...args];
+        commandPath = process.execPath;
+    } else {
+        const localBinPath = path.join(NODE_MODULES_BIN, command);
+        if (fs.existsSync(localBinPath)) {
+            commandPath = localBinPath;
+        }
     }
 
     return new Promise((resolve, reject) => {
-        const serverProcess = spawn(commandPath, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+        const serverProcess = spawn(commandPath, spawnArgs, { stdio: ['pipe', 'pipe', 'pipe'] });
         const parser = createParser(serverId);
 
         const serverState = {
diff --git a/src/extensions/default/DefaultExtensions.json b/src/extensions/default/DefaultExtensions.json
index 7076ad7306..68032c2994 100644
--- a/src/extensions/default/DefaultExtensions.json
+++ b/src/extensions/default/DefaultExtensions.json
@@ -28,7 +28,8 @@
   ],
   "desktopOnly": [
     "Git",
-    "TypeScriptSupport"
+    "TypeScriptSupport",
+    "PHPSupport"
   ],
  "warnExtensionStoreExtensions": {
    "description": "list extension ids here that you want to show this warning in extension store: 'You may not need this extension. Phoenix comes built in with this feature.'",
diff --git a/src/extensions/default/HTMLCodeHints/html-lint.js b/src/extensions/default/HTMLCodeHints/html-lint.js
index f858fe57f6..5e22436504 100644
--- a/src/extensions/default/HTMLCodeHints/html-lint.js
+++ b/src/extensions/default/HTMLCodeHints/html-lint.js
@@ -80,12 +80,25 @@ define(function (require, exports, module) {
      * Run JSLint on the current document. Reports results to the main UI. Displays
      * a gold star when no errors are found.
      */
+    // html-validate cannot tokenize php blocks ("failed to tokenize <?php ..." parser errors on
+    // every php file). Blank them out with same-length whitespace - newlines preserved - so the
+    // surrounding HTML is linted normally and every reported position stays valid. Handles
+    // <?php ... ?>, <?= ... ?> and an unterminated <? ... at EOF (pure-php files lint clean).
+    function _blankPhpRegions(text) {
+        return text.replace(/<\?(?:php|=)?[\s\S]*?(?:\?>|$)/g, function (block) {
+            return block.replace(/[^\n]/g, " ");
+        });
+    }
+
     async function lintOneFile(text, fullPath) {
         return new Promise((resolve, reject)=>{
             if(configErrorMessage){
                 resolve({ errors: _getLinterConfigFileErrorMsg() });
                 return;
             }
+            if(/\.(php\d?|phtml?|phps|ctp)$/i.test(fullPath)) {
+                text = _blankPhpRegions(text);
+            }
             IndexingWorker.execPeer("htmlLint", {
                 text,
                 filePath: fullPath,
diff --git a/src/extensions/default/HTMLCodeHints/main.js b/src/extensions/default/HTMLCodeHints/main.js
index ccbee8c02a..ef2c8fec36 100644
--- a/src/extensions/default/HTMLCodeHints/main.js
+++ b/src/extensions/default/HTMLCodeHints/main.js
@@ -93,6 +93,14 @@ define(function (require, exports, module) {
         if (enabled) {
             this.editor = editor;
 
+            // php files are mixed-mode: their HTML regions report "html" at the cursor and are
+            // served through the html registration. So a cursor whose language is actually "php"
+            // is inside real PHP code (<?php ... ?>), where markup abbreviations are never right -
+            // typing `addition(` there must not summon an Emmet hint.
+            if (editor.getLanguageForSelection().getId() === "php") {
+                return false;
+            }
+
             // check the context before showing emmet hints, because we don't want to show
             // emmet hints when its a Attribute name or value
             // cause for those cases AttrHints should handle it
diff --git a/src/extensions/default/HTMLCodeHints/unittests.js b/src/extensions/default/HTMLCodeHints/unittests.js
index 84d870dccd..73f4afbb06 100644
--- a/src/extensions/default/HTMLCodeHints/unittests.js
+++ b/src/extensions/default/HTMLCodeHints/unittests.js
@@ -695,6 +695,35 @@ define(function (require, exports, module) {
 
         describe("Emmet hint provider", function () {
 
+            it("should not offer emmet inside php code regions, only in html regions of php files", function () {
+                // php is a mixed mode: <?php ... ?> regions are real PHP (emmet is never right
+                // there - e.g. typing `addition(`), while the surrounding markup is HTML where
+                // emmet must keep working.
+                const phpContent = "<?php\n" +
+                    "$x = 1;\n" +
+                    "function addition(\n" +
+                    "?>\n" +
+                    "<div>\n" +
+                    "div\n" +
+                    "</div>\n";
+                const phpDocument = SpecRunnerUtils.createMockDocument(phpContent, "php");
+                $("body").append("<div id='php-editor'/>");
+                const phpEditor = new Editor(phpDocument, true, $("#php-editor").get(0));
+
+                // cursor inside the php code region, right after `addition(`
+                phpEditor.setCursorPos({ line: 2, ch: 18 });
+                expect(phpEditor.getLanguageForSelection().getId()).toBe("php");
+                expect(HTMLCodeHints.emmetHintProvider.hasHints(phpEditor, null)).toBe(false);
+
+                // cursor in the html region after "div" - emmet abbreviation expansion still works
+                phpEditor.setCursorPos({ line: 5, ch: 3 });
+                expect(phpEditor.getLanguageForSelection().getId()).not.toBe("php");
+                expect(HTMLCodeHints.emmetHintProvider.hasHints(phpEditor, null)).toBe(true);
+
+                phpEditor.destroy();
+                $("#php-editor").remove();
+            });
+
             it("should display emmet hint and expand to boilerplate code on ! press", function () {
 
                 let emmetBoilerPlate = [
diff --git a/src/extensions/default/JavaScriptCodeHints/main.js b/src/extensions/default/JavaScriptCodeHints/main.js
index 37990a9ab3..2f9c1c84a4 100644
--- a/src/extensions/default/JavaScriptCodeHints/main.js
+++ b/src/extensions/default/JavaScriptCodeHints/main.js
@@ -705,9 +705,13 @@ define(function (require, exports, module) {
                 ? LanguageManager.getLanguageForPath(editor.document.file.fullPath).getId()
                 : null;
 
-            // When the TypeScript language server serves this language, defer to it entirely: don't
-            // create a Tern session, so ScopeManager never indexes the project alongside the server.
-            if (_lspServesLanguage(languageId)) {
+            // When a language server serves this language, defer to it entirely: don't create a
+            // Tern session, so ScopeManager never indexes the project alongside the server.
+            // EXCEPT inline-script host documents (html, php): a server claiming those (e.g.
+            // Intelephense for php) serves only the host language, not the embedded <script> JS -
+            // Tern must keep its session there or embedded-JS intelligence dies. Feature routing
+            // by cursor language already keeps the two from overlapping.
+            if (_lspServesLanguage(languageId) && _inlineScriptLanguages.indexOf(languageId) === -1) {
                 session = null;
                 return;
             }
diff --git a/src/extensions/default/PHPSupport/ServerInstaller.js b/src/extensions/default/PHPSupport/ServerInstaller.js
new file mode 100644
index 0000000000..82bca7b0c2
--- /dev/null
+++ b/src/extensions/default/PHPSupport/ServerInstaller.js
@@ -0,0 +1,379 @@
+/*
+ * GNU AGPL-3.0 License
+ *
+ * Copyright (c) 2021 - present core.ai . All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://opensource.org/licenses/AGPL-3.0.
+ *
+ */
+
+/**
+ * ServerInstaller - on-demand acquisition of the Intelephense PHP language server.
+ *
+ * Intelephense is proprietary freeware: its license permits individual users to pair it with an
+ * LSP-capable editor but forbids redistributing/bundling it. So it is NOT part of the app - the
+ * user consents via an unobtrusive prompt (a toast plus a Problems-panel row, mirroring the
+ * TypeScript enable flow) and a pinned version is then npm-installed from the public registry
+ * into the app-data directory (the user acquires it personally - the license's intended use).
+ * Installation runs as a status-bar TASK (TaskManager) with progress, using the bundled npm via
+ * the existing node plumbing (NodeUtils._npmInstallInFolder) - no system npm or PHP runtime
+ * needed. Works identically on Windows, macOS and Linux (no shell, no .bin shims).
+ *
+ * Layout under <appSupport>/lspServers/intelephense/:
+ *   package.json                                     (written by us, exact version pin)
+ *   node_modules/intelephense/lib/intelephense.js    (the server entry)
+ *   cache/                                           (intelephense index cache - storagePath)
+ *
+ * Version upgrades: bumping INTELEPHENSE_VERSION makes the next start detect the pin mismatch,
+ * wipe node_modules + lockfile, reinstall silently (consent already given) and pass clearCache
+ * to the server once.
+ *
+ * @module extensions/default/PHPSupport/ServerInstaller
+ */
+define(function (require, exports, module) {
+
+
+    const NodeUtils = brackets.getModule("utils/NodeUtils"),
+        ProjectManager = brackets.getModule("project/ProjectManager"),
+        NativeApp = brackets.getModule("utils/NativeApp"),
+        ModalBar = brackets.getModule("widgets/ModalBar").ModalBar,
+        NotificationUI = brackets.getModule("widgets/NotificationUI"),
+        TaskManager = brackets.getModule("features/TaskManager"),
+        PreferencesManager = brackets.getModule("preferences/PreferencesManager"),
+        StringUtils = brackets.getModule("utils/StringUtils"),
+        Strings = brackets.getModule("strings");
+
+    const INTELEPHENSE_VERSION = "1.18.5";
+    const PREF_PHP_CODE_INTELLIGENCE = "php.codeIntelligence";
+
+    const INTELEPHENSE_HOME_URL = "https://intelephense.com";
+
+    let _onInstalled = null;        // main.js callback: ({entryPath, upgraded}) => void
+    let _inFlight = null;           // single-flight install promise
+    // projects where the user clicked "Not Now" - the bar stops reappearing there for the
+    // session. Until then it returns on every php file switch (closing on switch-away is not a
+    // dismissal - only the explicit button is).
+    const _promptDismissedForProject = new Set();
+    let _promptBar = null;          // the ModalBar install prompt, when showing
+    let _promptBarTip = null;       // the benefits tooltip binding on the bar's info icon
+    let _panelRowDismissed = false; // Problems-panel row dismissed this session
+
+    function _installDirVfs() {
+        return Phoenix.VFS.getAppSupportDir() + "lspServers/intelephense/";
+    }
+
+    function _entryVfs() {
+        return _installDirVfs() + "node_modules/intelephense/lib/intelephense.js";
+    }
+
+    function _packageJsonVfs() {
+        return _installDirVfs() + "package.json";
+    }
+
+    /**
+     * The platform (real disk) path of the server entry script, for spawning.
+     * @return {string}
+     */
+    function getEntryPlatformPath() {
+        return Phoenix.fs.getTauriPlatformPath(_entryVfs());
+    }
+
+    /**
+     * The platform path of the index-cache directory handed to the server as storagePath.
+     * No trailing separator - safest across platforms and path joins inside the server.
+     * @return {string}
+     */
+    function getCachePlatformPath() {
+        return Phoenix.fs.getTauriPlatformPath(_installDirVfs() + "cache");
+    }
+
+    /**
+     * @return {Promise<{installed: boolean, pinMatches: boolean}>}
+     */
+    async function installedState() {
+        const entryExists = await Phoenix.VFS.existsAsync(_entryVfs());
+        if (!entryExists) {
+            return { installed: false, pinMatches: false };
+        }
+        try {
+            const pkgText = await Phoenix.VFS.readFileAsync(_packageJsonVfs(), "utf8");
+            const pinned = JSON.parse(pkgText).dependencies.intelephense;
+            return { installed: true, pinMatches: pinned === INTELEPHENSE_VERSION };
+        } catch (e) {
+            return { installed: true, pinMatches: false };
+        }
+    }
+
+    // ----- install mechanics ----------------------------------------------------------------------
+
+    async function _writePinnedPackageJson() {
+        const pkg = {
+            name: "phcode-php-tooling",
+            private: true,
+            description: "Locally installed PHP language server for Phoenix Code. Managed automatically.",
+            dependencies: {}
+        };
+        pkg.dependencies.intelephense = INTELEPHENSE_VERSION;
+        await Phoenix.VFS.writeFileAsync(_packageJsonVfs(), JSON.stringify(pkg, null, 4), "utf8");
+    }
+
+    // Upgrade: wipe the old tree first - a stale package-lock.json vs rewritten package.json makes
+    // the node-side `npm ci` branch fail on manifest mismatch.
+    async function _wipeForUpgrade() {
+        try {
+            await Phoenix.VFS.unlinkAsync(_installDirVfs() + "node_modules");
+        } catch (e) {
+            // didn't exist - fine
+        }
+        try {
+            await Phoenix.VFS.unlinkAsync(_installDirVfs() + "package-lock.json");
+        } catch (e) {
+            // didn't exist - fine
+        }
+    }
+
+    async function _doInstall() {
+        const state = await installedState();
+        if (state.installed && state.pinMatches) {
+            return { entryPath: getEntryPlatformPath(), upgraded: false };
+        }
+        const upgrading = state.installed;
+        hidePanelRow();
+        // Status-bar task: visible progress the user can track from anywhere in the app. npm gives
+        // no byte-level progress through execFile, so this advances by phase.
+        const task = TaskManager.addNewTask(Strings.PHP_INSTALL_TITLE, Strings.PHP_INSTALLING,
+            "<i class='fa-brands fa-php'></i>", { progressPercent: 5 });
+        task.show();
+        try {
+            if (upgrading) {
+                await _wipeForUpgrade();
+            }
+            task.setProgressPercent(15);
+            await Phoenix.VFS.ensureExistsDirAsync(_installDirVfs());
+            await Phoenix.VFS.ensureExistsDirAsync(_installDirVfs() + "cache/");
+            await _writePinnedPackageJson();
+            task.setProgressPercent(25);
+            const platformDir = Phoenix.fs.getTauriPlatformPath(_installDirVfs());
+            await NodeUtils._npmInstallInFolder(platformDir);
+            task.setProgressPercent(90);
+            const ok = await Phoenix.VFS.existsAsync(_entryVfs());
+            if (!ok) {
+                throw new Error("intelephense entry missing after npm install");
+            }
+            task.setProgressPercent(100);
+            task.setMessage(Strings.PHP_INSTALL_DONE);
+            task.setSucceded(); // (sic - TaskManager's exported name)
+            setTimeout(task.close, 4000);
+            return { entryPath: getEntryPlatformPath(), upgraded: upgrading };
+        } catch (err) {
+            const message = (err && err.message) || String(err);
+            task.setFailed();
+            task.setMessage(StringUtils.format(Strings.PHP_INSTALL_FAILED, message));
+            setTimeout(task.close, 10000);
+            return null;
+        }
+    }
+
+    /**
+     * Install (or upgrade) now - single-flighted. On success, notifies the onInstalled callback so
+     * the language server can start immediately.
+     * @return {Promise<?{entryPath: string, upgraded: boolean}>} null on failure
+     */
+    function installNow() {
+        if (_inFlight) {
+            return _inFlight;
+        }
+        _inFlight = _doInstall().then(function (result) {
+            if (result && _onInstalled) {
+                _onInstalled(result);
+            }
+            return result;
+        }).finally(function () {
+            _inFlight = null;
+        });
+        return _inFlight;
+    }
+
+    // ----- consent UI: prompt toast + Problems-panel row (mirrors the TS enable affordances) ------
+
+    function _closePromptBar() {
+        if (_promptBarTip) {
+            _promptBarTip.detach();
+            _promptBarTip = null;
+        }
+        if (_promptBar) {
+            _promptBar.close();
+            _promptBar = null;
+        }
+    }
+
+    // Compact benefits card for the bar's (i) icon - term -> what it means, one line each.
+    function _benefitsTipHtml() {
+        const $tip = $("<div>");
+        $("<div class='ph-tip-title'>").text(Strings.PHP_INSTALL_TITLE).appendTo($tip);
+        const $rows = $("<div class='ph-tip-rows'>").appendTo($tip);
+        [
+            [Strings.PHP_BENEFIT_COMPLETIONS, Strings.PHP_BENEFIT_COMPLETIONS_SUB],
+            [Strings.PHP_BENEFIT_DOCS, Strings.PHP_BENEFIT_DOCS_SUB],
+            [Strings.PHP_BENEFIT_ERRORS, Strings.PHP_BENEFIT_ERRORS_SUB],
+            [Strings.PHP_BENEFIT_NAV, Strings.PHP_BENEFIT_NAV_SUB]
+        ].forEach(function (row) {
+            $("<span class='ph-tip-term'>").text(row[0]).appendTo($rows);
+            $("<span class='ph-tip-def'>").text(row[1]).appendTo($rows);
+        });
+        return $tip.html();
+    }
+
+    // A find-bar-style banner across the top of the editor - impossible to miss on the file that
+    // triggered it, but passive (autoClose false: clicking back into the code doesn't dismiss it).
+    function _showPromptBar() {
+        const root = ProjectManager.getProjectRoot();
+        const rootPath = (root && root.fullPath) || "";
+        if (_promptDismissedForProject.has(rootPath) || _promptBar) {
+            return;
+        }
+        // built as detached DOM then serialized (ModalBar takes an HTML string); all click
+        // handling is delegated on the live bar root below
+        const $tpl = $("<div class='php-install-bar'>");
+        $("<span class='php-install-bar-text'>").text(Strings.PHP_INSTALL_MESSAGE).appendTo($tpl);
+        $("<i class='fa-solid fa-circle-info php-install-bar-info'>").appendTo($tpl);
+        // credit where due (and where premium lives) - not license-required, just right
+        $("<a class='php-intel-powered-by' href='#'>").text(Strings.PHP_POWERED_BY_INTELEPHENSE)
+            .appendTo($tpl);
+        $("<button class='btn btn-mini php-install-bar-later'>")
+            .text(Strings.PHP_INSTALL_NOT_NOW).appendTo($tpl);
+        $("<button class='btn btn-mini primary php-install-bar-install'>")
+            .text(Strings.PHP_INSTALL_ENABLE).appendTo($tpl);
+
+        _promptBar = new ModalBar($tpl[0].outerHTML, false);
+        const $bar = _promptBar.getRoot();
+        _promptBarTip = NotificationUI.attachRichTooltip(
+            $bar.find(".php-install-bar-info"), _benefitsTipHtml(), { showDelayMs: 150 });
+        $bar.on("click", ".php-install-bar-install", function () {
+            _closePromptBar();
+            installNow();
+        });
+        $bar.on("click", ".php-install-bar-later", function () {
+            const projRoot = ProjectManager.getProjectRoot();
+            _promptDismissedForProject.add((projRoot && projRoot.fullPath) || "");
+            _closePromptBar();
+        });
+        $bar.on("click", ".php-intel-powered-by", function (e) {
+            e.preventDefault();
+            NativeApp.openURLInDefaultBrowser(INTELEPHENSE_HOME_URL);
+        });
+    }
+
+    function _ensurePanelRow() {
+        const $panel = $("#problems-panel");
+        if (!$panel.length) {
+            return null;
+        }
+        let $row = $panel.find(".php-intel-panel-row");
+        if ($row.length) {
+            return $row;
+        }
+        // reuse the TS row's styling; the extra class scopes our own lookups
+        $row = $("<div class='ts-code-intel-panel-row php-intel-panel-row'>").hide();
+        $("<span class='ts-code-intel-panel-text'>").text(Strings.PHP_PANEL_TEXT).appendTo($row);
+        $("<button class='btn btn-mini primary ts-code-intel-panel-enable'>")
+            .text(Strings.PHP_INSTALL_ENABLE)
+            .on("click", function () {
+                installNow();
+            })
+            .appendTo($row);
+        $("<a class='ts-code-intel-panel-close'>")
+            .attr("title", Strings.PHP_INSTALL_NOT_NOW).html("&times;")
+            .on("click", function () {
+                _panelRowDismissed = true; // session-only: reappears next launch
+                $row.hide();
+            })
+            .appendTo($row);
+        $panel.children(".toolbar").after($row);
+        return $row;
+    }
+
+    /**
+     * Hide the Problems-panel install row (e.g. once an install starts or completes).
+     */
+    function hidePanelRow() {
+        const $row = $("#problems-panel .php-intel-panel-row");
+        if ($row.length) {
+            $row.hide();
+        }
+    }
+
+    /**
+     * Show/hide the Problems-panel install row for the current state. Call on active-editor and
+     * project changes with whether a PHP DOCUMENT is active.
+     * @param {boolean} phpDocumentActive
+     */
+    function updatePanelRow(phpDocumentActive) {
+        if (typeof Phoenix !== "undefined" && Phoenix.isTestWindow) {
+            return;
+        }
+        const $row = _ensurePanelRow();
+        if (!$row) {
+            return;
+        }
+        if (!phpDocumentActive) {
+            _closePromptBar();  // the bar belongs to the php file that triggered it
+        }
+        if (!phpDocumentActive || _panelRowDismissed || _inFlight ||
+                PreferencesManager.get(PREF_PHP_CODE_INTELLIGENCE) === false) {
+            $row.hide();
+            return;
+        }
+        installedState().then(function (state) {
+            if (state.installed) {
+                $row.hide();
+            } else {
+                $row.show();
+            }
+        });
+    }
+
+    /**
+     * Offer the install to the user: one-per-session prompt toast + the persistent Problems-panel
+     * row. Call when a PHP document is active but the server is not installed.
+     * @param {boolean} phpDocumentActive
+     */
+    function offerInstallUI(phpDocumentActive) {
+        if (typeof Phoenix !== "undefined" && Phoenix.isTestWindow) {
+            return;
+        }
+        if (phpDocumentActive) {
+            _showPromptBar();
+        }
+        updatePanelRow(phpDocumentActive);
+    }
+
+    /**
+     * @param {{onInstalled: function({entryPath: string, upgraded: boolean})}} options
+     */
+    function init(options) {
+        _onInstalled = (options && options.onInstalled) || null;
+    }
+
+    exports.init = init;
+    exports.installedState = installedState;
+    exports.installNow = installNow;
+    exports.offerInstallUI = offerInstallUI;
+    exports.updatePanelRow = updatePanelRow;
+    exports.hidePanelRow = hidePanelRow;
+    exports.getEntryPlatformPath = getEntryPlatformPath;
+    exports.getCachePlatformPath = getCachePlatformPath;
+    exports.INTELEPHENSE_VERSION = INTELEPHENSE_VERSION;
+    exports.PREF_PHP_CODE_INTELLIGENCE = PREF_PHP_CODE_INTELLIGENCE;
+});
diff --git a/src/extensions/default/PHPSupport/main.js b/src/extensions/default/PHPSupport/main.js
new file mode 100644
index 0000000000..82f3a7040c
--- /dev/null
+++ b/src/extensions/default/PHPSupport/main.js
@@ -0,0 +1,254 @@
+/*
+ * GNU AGPL-3.0 License
+ *
+ * Copyright (c) 2021 - present core.ai . All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://opensource.org/licenses/AGPL-3.0.
+ *
+ */
+
+/**
+ * PHPSupport - PHP code intelligence via the Intelephense language server: completion with docs,
+ * hover, signature help, jump-to-definition, find references and diagnostics, all through the
+ * shared LSP framework. Desktop only.
+ *
+ * The server is proprietary freeware and cannot ship with the app - see ServerInstaller for the
+ * consent + on-demand npm install flow. Embedded JS/CSS/HTML inside .php files stays served by
+ * the existing editors' providers (Tern et al); Intelephense serves the PHP regions.
+ *
+ * @module extensions/default/PHPSupport/main
+ */
+define(function (require, exports, module) {
+
+
+    const AppInit = brackets.getModule("utils/AppInit"),
+        ProjectManager = brackets.getModule("project/ProjectManager"),
+        EditorManager = brackets.getModule("editor/EditorManager"),
+        PreferencesManager = brackets.getModule("preferences/PreferencesManager"),
+        NodeConnector = brackets.getModule("NodeConnector"),
+        Strings = brackets.getModule("strings"),
+        ServerInstaller = require("./ServerInstaller");
+
+    const SERVER_ID = "php";
+    const SUPPORTED_LANGUAGES = ["php"];
+    const PREF_LICENSE_KEY = "php.licenseKey";
+
+    // Master switch; also doubles as the durable memory of a declined install prompt (the
+    // decline sets it false; setting it back to true re-offers the install).
+    PreferencesManager.definePreference(ServerInstaller.PREF_PHP_CODE_INTELLIGENCE, "boolean", true, {
+        description: Strings.DESCRIPTION_PHP_CODE_INTELLIGENCE
+    });
+    // Intelephense premium licence key (or an absolute path to a key file). Owners of a licence
+    // configured via the standard global licence file need not set this - the server finds that
+    // file by itself.
+    PreferencesManager.definePreference(PREF_LICENSE_KEY, "string", "", {
+        description: Strings.DESCRIPTION_PHP_LICENSE_KEY
+    });
+
+    // Mutated in place before a restart when the licence key changes - registerLanguageServer
+    // keeps a reference to this object, so restarts pick the new values up.
+    const INITIALIZATION_OPTIONS = {};
+
+    let lspClientPromise = null;
+    let registered = false;
+    let starting = false;
+    let pendingRepoint = false;
+    let initErrorReported = false;
+
+    function canRun() {
+        return Phoenix.isNativeApp && NodeConnector.isNodeAvailable();
+    }
+
+    function loadLSPClient() {
+        if (!lspClientPromise) {
+            lspClientPromise = new Promise(function (resolve, reject) {
+                brackets.getModule(["languageTools/LSPClient"], resolve, function () {
+                    setTimeout(function () {
+                        brackets.getModule(["languageTools/LSPClient"], resolve, reject);
+                    }, 500);
+                });
+            });
+        }
+        return lspClientPromise;
+    }
+
+    function waitForNodeReady(timeout) {
+        return new Promise(function (resolve) {
+            const deadline = Date.now() + timeout;
+            (function check() {
+                if (NodeConnector.isNodeReady()) {
+                    resolve(true);
+                } else if (Date.now() > deadline) {
+                    resolve(false);
+                } else {
+                    setTimeout(check, 300);
+                }
+            }());
+        });
+    }
+
+    function _refreshInitializationOptions(clearCache) {
+        const licenseKey = (PreferencesManager.get(PREF_LICENSE_KEY) || "").trim();
+        // note the server's British spelling: licenceKey
+        INITIALIZATION_OPTIONS.licenceKey = licenseKey || undefined;
+        INITIALIZATION_OPTIONS.storagePath = ServerInstaller.getCachePlatformPath();
+        INITIALIZATION_OPTIONS.globalStoragePath = ServerInstaller.getCachePlatformPath();
+        INITIALIZATION_OPTIONS.clearCache = !!clearCache;
+    }
+
+    async function _registerServer(entryPath, upgraded) {
+        if (registered) {
+            return;
+        }
+        const LSPClient = await loadLSPClient();
+        _refreshInitializationOptions(upgraded);
+        const client = await LSPClient.registerLanguageServer({
+            serverId: SERVER_ID,
+            command: entryPath,                 // absolute .js entry, spawned on phnode itself
+            args: ["--stdio"],
+            languages: SUPPORTED_LANGUAGES,
+            languageIdMap: { php: "php" },
+            initializationOptions: INITIALIZATION_OPTIONS
+        });
+        if (client) {
+            registered = true;
+        }
+    }
+
+    async function start() {
+        if (registered || !canRun()) {
+            return;
+        }
+        const ready = await waitForNodeReady(30000);
+        if (!ready) {
+            console.error("[PHPSupport] Node not ready - PHP LSP disabled");
+            return;
+        }
+        const state = await ServerInstaller.installedState();
+        if (!state.installed) {
+            // not acquired yet: offer the unobtrusive consent UI (prompt toast + Problems-panel
+            // row). Clicking Install runs the installer; its onInstalled callback starts us.
+            ServerInstaller.offerInstallUI(_isPhpDocumentActive());
+            return;
+        }
+        if (!state.pinMatches) {
+            // silent version upgrade - consent was given when it first installed
+            const result = await ServerInstaller.installNow();
+            if (!result) {
+                return;
+            }
+            // installNow's onInstalled callback registers the server
+            return;
+        }
+        await _registerServer(ServerInstaller.getEntryPlatformPath(), false);
+    }
+
+    /**
+     * True when the active editor's DOCUMENT is PHP. Deliberately not getLanguageForSelection:
+     * the php mode is mixed, so a cursor inside an embedded <script> reports "javascript" - but
+     * a php file is open either way and the server should be up.
+     * @return {boolean}
+     */
+    function _isPhpDocumentActive() {
+        const editor = EditorManager.getActiveEditor();
+        if (!editor || !editor.document) {
+            return false;
+        }
+        return editor.document.getLanguage().getId() === "php";
+    }
+
+    function _ensureServerForActiveEditor() {
+        if (!canRun() || !_isPhpDocumentActive()) {
+            return;
+        }
+        if (PreferencesManager.get(ServerInstaller.PREF_PHP_CODE_INTELLIGENCE) === false) {
+            return;
+        }
+        if (!registered) {
+            if (starting) {
+                return;
+            }
+            starting = true;
+            pendingRepoint = false;
+            start().catch(function (err) {
+                if (!initErrorReported) {
+                    initErrorReported = true;
+                    window.logger && window.logger.reportError(err, "[PHPSupport] PHP LSP init failed");
+                }
+            }).finally(function () {
+                starting = false;
+            });
+            return;
+        }
+        if (pendingRepoint) {
+            pendingRepoint = false;
+            loadLSPClient().then(function (LSPClient) {
+                LSPClient.changeWorkspaceRoot(SERVER_ID);
+            });
+        }
+    }
+
+    // Pre-warm the framework module (not the server) as soon as the extension loads.
+    if (canRun()) {
+        loadLSPClient();
+    }
+
+    AppInit.appReady(function () {
+        if (!canRun()) {
+            return;
+        }
+
+        ServerInstaller.init({
+            onInstalled: function (result) {
+                _registerServer(result.entryPath, result.upgraded).catch(function (err) {
+                    window.logger && window.logger.reportError(err, "[PHPSupport] start after install failed");
+                });
+            }
+        });
+
+        EditorManager.on("activeEditorChange.phpSupport", function () {
+            _ensureServerForActiveEditor();
+            ServerInstaller.updatePanelRow(_isPhpDocumentActive() && !registered);
+        });
+        _ensureServerForActiveEditor();
+
+        ProjectManager.on(ProjectManager.EVENT_PROJECT_OPEN + ".phpSupport", function () {
+            pendingRepoint = true;
+            _ensureServerForActiveEditor();
+        });
+
+        // Licence key change: restart the running server so the new key applies (premium features
+        // activate server-side at initialize time). If not running yet, the next start picks it up.
+        PreferencesManager.on("change", PREF_LICENSE_KEY, function () {
+            if (registered) {
+                _refreshInitializationOptions(false);
+                loadLSPClient().then(function (LSPClient) {
+                    LSPClient.restartLanguageServer(SERVER_ID);
+                });
+            }
+        });
+
+        // Master switch flipped back on (e.g. after an earlier decline): offer install again on
+        // the currently open php file.
+        PreferencesManager.on("change", ServerInstaller.PREF_PHP_CODE_INTELLIGENCE, function () {
+            if (PreferencesManager.get(ServerInstaller.PREF_PHP_CODE_INTELLIGENCE) !== false) {
+                _ensureServerForActiveEditor();
+            }
+        });
+    });
+
+    // for tests
+    exports._ensureServerForActiveEditor = _ensureServerForActiveEditor;
+    exports.SERVER_ID = SERVER_ID;
+});
diff --git a/src/extensions/default/PHPSupport/package.json b/src/extensions/default/PHPSupport/package.json
new file mode 100644
index 0000000000..45492957fb
--- /dev/null
+++ b/src/extensions/default/PHPSupport/package.json
@@ -0,0 +1,9 @@
+{
+    "name": "php-support",
+    "title": "PHP Language Support",
+    "description": "Provides PHP language intelligence (completion, hover, signature help, jump-to-definition, find references and diagnostics) via the Intelephense language server, installed on demand with user consent. Desktop only.",
+    "version": "1.0.0",
+    "engines": {
+        "brackets": ">=2.0.0"
+    }
+}
diff --git a/src/extensions/default/PHPSupport/unittests.js b/src/extensions/default/PHPSupport/unittests.js
new file mode 100644
index 0000000000..fcb15c65dd
--- /dev/null
+++ b/src/extensions/default/PHPSupport/unittests.js
@@ -0,0 +1,156 @@
+/*
+ * GNU AGPL-3.0 License
+ *
+ * Copyright (c) 2021 - present core.ai . All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://opensource.org/licenses/AGPL-3.0.
+ *
+ */
+
+/*global describe, it, expect, beforeAll, afterAll, awaitsFor, awaitsForDone */
+
+define(function (require, exports, module) {
+
+
+    if (!Phoenix.isNativeApp) {
+        // The PHP language server runs on node - desktop builds only.
+        return;
+    }
+
+    const SpecRunnerUtils = brackets.getModule("spec/SpecRunnerUtils");
+
+    describe("integration:PHP LSP", function () {
+        const testFolder = SpecRunnerUtils.getTestPath("/spec/PHPSupport-test-files");
+        let testWindow,
+            $,
+            CommandManager,
+            Commands,
+            EditorManager,
+            QuickViewManager;
+
+        // Resolve a module from the PHPSupport extension inside the test window.
+        function _phpModule(name) {
+            return new Promise(function (resolve, reject) {
+                const ExtensionLoader = testWindow.brackets.test.ExtensionLoader;
+                const ctx = ExtensionLoader.getRequireContextForExtension("PHPSupport");
+                ctx([name], resolve, reject);
+            });
+        }
+
+        async function _openFile(fileName) {
+            await awaitsForDone(
+                CommandManager.execute(Commands.CMD_ADD_TO_WORKINGSET_AND_OPEN,
+                    { fullPath: testFolder + "/" + fileName }));
+        }
+
+        function _problemsText() {
+            return $("#problems-panel").text();
+        }
+
+        beforeAll(async function () {
+            testWindow = await SpecRunnerUtils.createTestWindowAndRun();
+            $ = testWindow.$;
+            CommandManager = testWindow.brackets.test.CommandManager;
+            Commands = testWindow.brackets.test.Commands;
+            EditorManager = testWindow.brackets.test.EditorManager;
+            QuickViewManager = testWindow.brackets.getModule("features/QuickViewManager");
+            await SpecRunnerUtils.loadProjectInTestWindow(testFolder);
+
+            // Acquire the server directly (the consent UI is suppressed in test windows). First CI
+            // run downloads ~9MB from npm; local runs hit the already-installed copy instantly.
+            const ServerInstaller = await _phpModule("ServerInstaller");
+            const result = await ServerInstaller.installNow();
+            if (!result) {
+                throw new Error("Intelephense install failed - network needed for the first run");
+            }
+
+            // Warm-up: opening a php file lazily starts the server; the first diagnostic is the
+            // readiness signal. First-ever start also builds the stub index - generous budget.
+            await _openFile("error.php");
+            await awaitsFor(function () {
+                return /php \(/.test(_problemsText());
+            }, "first Intelephense diagnostics in the problems panel", 120000);
+        }, 240000);
+
+        afterAll(async function () {
+            testWindow = null;
+            await SpecRunnerUtils.closeTestWindow();
+        }, 30000);
+
+        it("should report PHP parse errors from the language server", async function () {
+            await _openFile("error.php");
+            await awaitsFor(function () {
+                // the fixture's dangling `->` draws a syntax diagnostic from intelephense
+                return /php \(/.test(_problemsText()) && /expected/i.test(_problemsText());
+            }, "php parse diagnostic", 30000);
+        }, 45000);
+
+        it("should mark the php linting provider active (and html/json untouched by it)", async function () {
+            const LSPClient = testWindow.brackets.getModule("languageTools/LSPClient");
+            expect(LSPClient.isLintingProviderActive("php")).toBe(true);
+            expect(LSPClient.isLintingProviderActive("html")).toBe(false);
+        }, 45000);
+
+        it("should show hover docs for a user-defined function", async function () {
+            await _openFile("funcs.php");
+            const editor = EditorManager.getActiveEditor();
+            const lines = editor.document.getText().split("\n");
+            const callLine = lines.findIndex(function (l) { return l.indexOf("echo computeTotal") !== -1; });
+            const pos = { line: callLine, ch: lines[callLine].indexOf("computeTotal") + 3 };
+            let hoverText = null;
+            await awaitsFor(function () {
+                return QuickViewManager._queryPreviewProviders(editor, pos, editor.getToken(pos))
+                    .then(function (popover) {
+                        if (popover && popover.content) {
+                            hoverText = $(popover.content).text();
+                        }
+                    }).then(function () {
+                        return hoverText && hoverText.indexOf("computeTotal") !== -1;
+                    });
+            }, "hover docs for computeTotal", 30000);
+            expect(hoverText).toContain("computeTotal");
+        }, 45000);
+
+        it("should jump to definition within the file", async function () {
+            await _openFile("funcs.php");
+            const editor = EditorManager.getActiveEditor();
+            const lines = editor.document.getText().split("\n");
+            const callLine = lines.findIndex(function (l) { return l.indexOf("echo computeTotal") !== -1; });
+            const defLine = lines.findIndex(function (l) { return l.indexOf("function computeTotal") !== -1; });
+            editor.setCursorPos({ line: callLine, ch: lines[callLine].indexOf("computeTotal") + 3 });
+            await awaitsForDone(CommandManager.execute(Commands.NAVIGATE_JUMPTO_DEFINITION));
+            await awaitsFor(function () {
+                return EditorManager.getActiveEditor().getCursorPos().line === defLine;
+            }, "cursor to land on the definition", 30000);
+        }, 45000);
+
+        it("should keep Tern serving embedded <script> JS inside php files", async function () {
+            await _openFile("embedded.php");
+            const editor = EditorManager.getActiveEditor();
+            const lines = editor.document.getText().split("\n");
+            const jsLine = lines.findIndex(function (l) { return l.indexOf("items.") !== -1; });
+            editor.setCursorPos({ line: jsLine, ch: lines[jsLine].indexOf("items.") + 6 });
+            // provider-level: the Tern-backed JS hint provider must claim the embedded JS cursor
+            // even though an LSP now serves the "php" document language (the inline-host gate fix)
+            const jsHintsMain = await new Promise(function (resolve, reject) {
+                const ExtensionLoader = testWindow.brackets.test.ExtensionLoader;
+                const ctx = ExtensionLoader.getRequireContextForExtension("JavaScriptCodeHints");
+                ctx(["main"], resolve, reject);
+            });
+            await awaitsFor(function () {
+                return jsHintsMain.jsHintProvider.hasHints(editor, null);
+            }, "Tern to claim the embedded-JS cursor in a php file", 30000);
+        }, 45000);
+    });
+});
diff --git a/src/languageTools/DefaultProviders.js b/src/languageTools/DefaultProviders.js
index 1294dd26a3..6eeee349e6 100644
--- a/src/languageTools/DefaultProviders.js
+++ b/src/languageTools/DefaultProviders.js
@@ -188,9 +188,19 @@ define(function (require, exports, module) {
         // that merely restates the label counts as "no signature".
         var label = (token.label || "").trim();
         var detail = (token.detail || "").trim();
-        if (detail && detail !== label) {
+        // Some servers (intelephense) split the signature across fields: labelDetails.detail holds
+        // the parameter list ("($search, $replace, ...)") and `detail` only the return type. Shown
+        // alone the return type reads like noise - compose the full signature instead. Only when
+        // labelDetails.detail is a parameter list and `detail` isn't already a full signature
+        // (vtsls puts the whole signature in `detail`, which must stay untouched).
+        var paramList = (token.labelDetails && token.labelDetails.detail || "").trim();
+        var signature = detail;
+        if (paramList.charAt(0) === "(" && detail.indexOf("(") === -1) {
+            signature = label + paramList + (detail ? ": " + detail : "");
+        }
+        if (signature && signature !== label) {
             try {
-                parts.push(_highlightCode(marked.parse("```" + _signatureLang() + "\n" + token.detail + "\n```")));
+                parts.push(_highlightCode(marked.parse("```" + _signatureLang() + "\n" + signature + "\n```")));
             } catch (e) {
                 // skip the signature block on any parse/highlight error
             }
@@ -300,6 +310,10 @@ define(function (require, exports, module) {
         }
     }
 
+    // Inline row details longer than this go to the side docs popup instead of the row (some
+    // servers - intelephense - put whole function signatures in `detail`, which bloats the list).
+    const INLINE_DETAIL_MAX_CHARS = 32;
+
     function _injectInlineSignature($labelSpan, detail) {
         if (!detail || !detail.trim() || detail.trim() === "?") {
             return;
@@ -566,7 +580,9 @@ define(function (require, exports, module) {
             // so this does not cause extra LSP requests. Skip it for auto-imports - their detail is a
             // long "Add import from <module>" string that just clips uselessly; the short source-module
             // tag stays visible there instead (see CSS), and the doc popup carries the full import.
-            if (token.detail && !_isAutoImport(token)) {
+            // Also skip LONG details (some servers - intelephense - put the whole function signature
+            // there, which bloats the rows): the side docs popup carries those instead.
+            if (token.detail && !_isAutoImport(token) && token.detail.length <= INLINE_DETAIL_MAX_CHARS) {
                 _injectInlineSignature($span, token.detail);
             }
             // Beside the list: the signature header + the (possibly long) documentation.
diff --git a/src/languageTools/LSPClient.js b/src/languageTools/LSPClient.js
index f4bf7c6492..e6b20d47ec 100644
--- a/src/languageTools/LSPClient.js
+++ b/src/languageTools/LSPClient.js
@@ -648,6 +648,11 @@ define(function (require, exports, module) {
                         // strips snippet placeholders on insert for such items.
                         snippetSupport: !!(config && config.completionSnippetSupport),
                         documentationFormat: ["markdown", "plaintext"],
+                        // LSP 3.16: servers only lazily fill (via completionItem/resolve) the
+                        // properties the client declares here - intelephense returns empty
+                        // completion docs without it. We resolve the highlighted item for the
+                        // docs popup, so declare exactly what that popup consumes.
+                        resolveSupport: { properties: ["documentation", "detail"] },
                         // We render labelDetails.detail/description (e.g. the source module of an
                         // auto-import) so otherwise-identical labels are distinguishable - see the
                         // CodeHintsProvider renderer.
diff --git a/src/nls/root/strings.js b/src/nls/root/strings.js
index 0827bf0bdb..3ae3d6bb9f 100644
--- a/src/nls/root/strings.js
+++ b/src/nls/root/strings.js
@@ -1800,6 +1800,26 @@ define({
     "CODE_INTEL_PANEL_TEXT": "Project-wide code intelligence is off. Enable it for Find Usages, Rename, and Go to Definition across every file — adds a jsconfig.json to the project root.",
     "CODE_INTEL_PANEL_ENABLE": "Enable",
     "CODE_INTEL_PANEL_DISMISS": "Dismiss",
+    // PHP language support (PHPSupport)
+    "PHP_INSTALL_TITLE": "PHP Code Intelligence",
+    "PHP_INSTALL_MESSAGE": "Install advanced PHP code intelligence?",
+    "PHP_INSTALL_ENABLE": "Install",
+    "PHP_INSTALL_NOT_NOW": "Not Now",
+    "PHP_POWERED_BY_INTELEPHENSE": "Powered by Intelephense",
+    "PHP_BENEFIT_COMPLETIONS": "Completions",
+    "PHP_BENEFIT_COMPLETIONS_SUB": "smart suggestions as you type",
+    "PHP_BENEFIT_DOCS": "Docs on hover",
+    "PHP_BENEFIT_DOCS_SUB": "function help right in the editor",
+    "PHP_BENEFIT_ERRORS": "Error checking",
+    "PHP_BENEFIT_ERRORS_SUB": "mistakes flagged as you code",
+    "PHP_BENEFIT_NAV": "Navigation",
+    "PHP_BENEFIT_NAV_SUB": "go to definition and find usages",
+    "PHP_PANEL_TEXT": "PHP code intelligence is off. Install the Intelephense language server (free, ~9 MB download) for completions, error checking, docs and go to definition.",
+    "PHP_INSTALLING": "Setting up PHP support — downloading the language server…",
+    "PHP_INSTALL_DONE": "PHP code intelligence is ready.",
+    "PHP_INSTALL_FAILED": "Could not set up PHP support: {0}. {APP_NAME} will retry when you open a PHP file again.",
+    "DESCRIPTION_PHP_CODE_INTELLIGENCE": "false to disable PHP code intelligence (Intelephense). Setting it back to true offers the language server download again.",
+    "DESCRIPTION_PHP_LICENSE_KEY": "Intelephense premium licence key (or an absolute path to a key file) enabling premium features like rename and code actions. Not needed if your licence is already in the standard global intelephense licence file.",
     // JSON / package.json intelligence (JSONSupport)
     "NPM_VULN_PROVIDER_NAME": "npm Security Advisories",
     "NPM_VULN_MESSAGE": "{0}@{1} is vulnerable: {2} ({3} severity)",
diff --git a/src/styles/brackets.less b/src/styles/brackets.less
index 79021c4d01..3d98d9ae8b 100644
--- a/src/styles/brackets.less
+++ b/src/styles/brackets.less
@@ -2220,6 +2220,48 @@ a, img {
     }
 }
 
+// PHP install prompt bar (PHPSupport) - find-bar-style banner across the editor top.
+.modal-bar .php-install-bar {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    .php-install-bar-text {
+        flex: none;      // hug the question so the (i) sits right after it
+        min-width: 0;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+    }
+    // sits right after the question; margin-right:auto pushes everything else to the right edge
+    .php-install-bar-info {
+        flex: none;
+        margin-left: -4px;
+        margin-right: auto;
+        opacity: 0.5;
+        cursor: default;
+        &:hover { opacity: 0.9; }
+    }
+    .php-intel-powered-by {
+        flex: none;
+        cursor: pointer;
+        white-space: nowrap;
+    }
+    button {
+        flex: none;
+        margin: 0;
+    }
+}
+
+// On bright colored toast surfaces (e.g. the PHP install prompt on INFO blue) the link-blue
+// action text is invisible - use high-contrast white bold links there, both themes.
+.notification-popup-container.style-info .ts-code-intel-action,
+.dark .notification-popup-container.style-info .ts-code-intel-action {
+    color: #fff;
+    font-weight: 600;
+    text-decoration: underline;
+    &:hover { color: rgba(255, 255, 255, 0.85); }
+}
+
 .lsp-hover-quickview {
     text-align: left;
     // The QuickView popover centers + shrink-wraps each provider's content (.quick-view-item is a
diff --git a/test/spec/PHPSupport-test-files/embedded.php b/test/spec/PHPSupport-test-files/embedded.php
new file mode 100644
index 0000000000..7488a7b408
--- /dev/null
+++ b/test/spec/PHPSupport-test-files/embedded.php
@@ -0,0 +1,9 @@
+<?php $title = "page"; ?>
+<html>
+<body>
+<script>
+var items = [1, 2, 3];
+items.
+</script>
+</body>
+</html>
diff --git a/test/spec/PHPSupport-test-files/error.php b/test/spec/PHPSupport-test-files/error.php
new file mode 100644
index 0000000000..f33d20c28e
--- /dev/null
+++ b/test/spec/PHPSupport-test-files/error.php
@@ -0,0 +1,5 @@
+<?php
+
+function broken(): string {
+    return $undefinedVariable->
+}
diff --git a/test/spec/PHPSupport-test-files/funcs.php b/test/spec/PHPSupport-test-files/funcs.php
new file mode 100644
index 0000000000..487b685803
--- /dev/null
+++ b/test/spec/PHPSupport-test-files/funcs.php
@@ -0,0 +1,7 @@
+<?php
+
+function computeTotal(int $a, int $b): int {
+    return $a + $b;
+}
+
+echo computeTotal(1, 2);