tsifdef 1.1.8

package/dist/vscode/extension.js

@@ -0,0 +1,241 @@
+"use strict";
+// Copyright (C) 2026 Tencent. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTypeScriptIntegration = createTypeScriptIntegration;
+exports.createHost = createHost;
+exports.ensureTsserverPluginModule = ensureTsserverPluginModule;
+exports.activate = activate;
+exports.deactivate = deactivate;
+const node_module_1 = require("node:module");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const version_js_1 = require("../version.js");
+const profile_state_js_1 = require("./profile-state.js");
+const macro_presentation_js_1 = require("./macro-presentation.js");
+const package_profile_js_1 = require("./package-profile.js");
+const document_analysis_js_1 = require("./document-analysis.js");
+const macroExtensionPattern = /\.(?:d\.)?(?:ts|tsx|mts|cts)$/i;
+const macroLanguageIds = new Set(["typescript", "typescriptreact"]);
+function isMacroDocument(document) {
+    return macroLanguageIds.has(document.languageId) || macroExtensionPattern.test(document.fileName);
+}
+function toSnapshot(document) {
+    return {
+        uri: document.uri.toString(),
+        isMacroDocument: isMacroDocument(document),
+        getText: () => document.getText(),
+    };
+}
+/** Optional bridge to VSCode's built-in TypeScript language service. */
+function createTypeScriptIntegration(vscode) {
+    return {
+        configurePlugin: async (name, configuration) => {
+            const extension = vscode.extensions.getExtension("vscode.typescript-language-features");
+            if (extension === undefined) {
+                return;
+            }
+            try {
+                const exports = (await extension.activate());
+                exports.getAPI?.(0)?.configurePlugin(name, configuration);
+            }
+            catch {
+                // The TypeScript language service is optional. Decorations and folding
+                // still work when it is unavailable or supplied by another extension.
+            }
+        },
+        restartServer: async () => {
+            if (vscode.extensions.getExtension("vscode.typescript-language-features") === undefined) {
+                return;
+            }
+            try {
+                await vscode.commands.executeCommand("typescript.restartTsServer");
+            }
+            catch {
+                // Keep the extension usable without VSCode's built-in tsserver.
+            }
+        },
+        reloadProjects: async () => {
+            if (vscode.extensions.getExtension("vscode.typescript-language-features") === undefined) {
+                return;
+            }
+            try {
+                await vscode.commands.executeCommand("typescript.reloadProjects");
+            }
+            catch {
+                // Keep the extension usable without VSCode's built-in tsserver.
+            }
+        },
+    };
+}
+/** Adapt the real `vscode` API to the host interface the shell depends on. */
+function createHost(vscode) {
+    const typeScript = createTypeScriptIntegration(vscode);
+    const decorationTypes = new Map();
+    let decorationSequence = 0;
+    const toRange = (range) => new vscode.Range(range.start.line, range.start.character, range.end.line, range.end.character);
+    const severities = {
+        [document_analysis_js_1.DiagnosticSeverity.error]: vscode.DiagnosticSeverity.Error,
+        [document_analysis_js_1.DiagnosticSeverity.warning]: vscode.DiagnosticSeverity.Warning,
+    };
+    const toDiagnostic = (diagnostic) => {
+        const created = new vscode.Diagnostic(toRange(diagnostic.range), diagnostic.message, severities[diagnostic.severity]);
+        created.code = diagnostic.code;
+        return created;
+    };
+    return {
+        createStatusBarItem: () => vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 100),
+        registerCommand: (command, handler) => vscode.commands.registerCommand(command, handler),
+        showInformationMessage: (message) => void vscode.window.showInformationMessage(message),
+        workspaceRoot: () => vscode.workspace.workspaceFolders?.[0]?.uri.fsPath,
+        createDiagnosticCollection: (name) => {
+            const collection = vscode.languages.createDiagnosticCollection(name);
+            return {
+                set: (uri, diagnostics) => collection.set(vscode.Uri.parse(uri), diagnostics.map(toDiagnostic)),
+                delete: (uri) => collection.delete(vscode.Uri.parse(uri)),
+                clear: () => collection.clear(),
+                dispose: () => collection.dispose(),
+            };
+        },
+        createInactiveDecorationType: () => {
+            const key = `inactive-${(decorationSequence += 1)}`;
+            const type = vscode.window.createTextEditorDecorationType({
+                opacity: "0.5",
+                isWholeLine: false,
+            });
+            decorationTypes.set(key, type);
+            return {
+                key,
+                dispose: () => {
+                    type.dispose();
+                    decorationTypes.delete(key);
+                },
+            };
+        },
+        setDecorations: (uri, decoration, ranges) => {
+            const type = decorationTypes.get(decoration.key);
+            if (type === undefined) {
+                return;
+            }
+            const vsRanges = ranges.map(toRange);
+            for (const editor of vscode.window.visibleTextEditors) {
+                if (editor.document.uri.toString() === uri) {
+                    editor.setDecorations(type, vsRanges);
+                }
+            }
+        },
+        macroDocuments: () => vscode.workspace.textDocuments.map(toSnapshot),
+        registerFoldingRangeProvider: (provider) => vscode.languages.registerFoldingRangeProvider([{ language: "typescript" }, { language: "typescriptreact" }], {
+            provideFoldingRanges: (document) => provider(toSnapshot(document)).map((fold) => new vscode.FoldingRange(fold.start, fold.end)),
+        }),
+        showErrorMessage: (message) => void vscode.window.showErrorMessage(message),
+        configureTypeScriptPlugin: typeScript.configurePlugin,
+        restartTypeScriptServer: typeScript.restartServer,
+        reloadTypeScriptProjects: typeScript.reloadProjects,
+        watchProjectConfiguration: (onChange) => {
+            const watcher = vscode.workspace.createFileSystemWatcher("**/{package.json,*.json}");
+            const subscriptions = [
+                watcher.onDidChange(onChange),
+                watcher.onDidCreate(onChange),
+                watcher.onDidDelete(onChange),
+            ];
+            return { dispose: () => { for (const item of subscriptions)
+                    item.dispose(); watcher.dispose(); } };
+        },
+    };
+}
+let active;
+/**
+ * Ensure the tsserver plugin is resolvable as `node_modules/tsifdef-tsserver`.
+ *
+ * tsserver loads a workspace plugin by resolving the module named in
+ * `typescriptServerPlugins` from the extension directory. vsce does not ship a
+ * `node_modules/` tree, so the compiled plugin would otherwise be unreachable
+ * and every `#if` would reach the parser as a syntax error. Recreate the tiny
+ * forwarder on activation so a fresh install (or a `--force` reinstall that
+ * wiped a previous shim) self-heals without manual steps.
+ */
+function ensureTsserverPluginModule() {
+    try {
+        // Compiled to `<ext>/dist/vscode/extension.js`; the extension root is two up.
+        const extensionRoot = (0, node_path_1.dirname)((0, node_path_1.dirname)(__dirname));
+        const moduleDir = (0, node_path_1.join)(extensionRoot, "node_modules", "tsifdef-tsserver");
+        const manifest = (0, node_path_1.join)(moduleDir, "package.json");
+        const index = (0, node_path_1.join)(moduleDir, "index.js");
+        const expectedManifest = `${JSON.stringify({ name: "tsifdef-tsserver", version: version_js_1.VERSION, private: true, main: "../../dist/tsserver/plugin.js" }, null, 2)}\n`;
+        const expectedIndex = 'module.exports = require("../../dist/tsserver/plugin.js");\n';
+        let currentManifest;
+        let currentIndex;
+        try {
+            currentManifest = (0, node_fs_1.readFileSync)(manifest, "utf8");
+            currentIndex = (0, node_fs_1.readFileSync)(index, "utf8");
+        }
+        catch {
+            currentManifest = undefined;
+            currentIndex = undefined;
+        }
+        if (currentManifest === expectedManifest && currentIndex === expectedIndex)
+            return;
+        (0, node_fs_1.mkdirSync)(moduleDir, { recursive: true });
+        (0, node_fs_1.writeFileSync)(manifest, expectedManifest, "utf8");
+        (0, node_fs_1.writeFileSync)(index, expectedIndex, "utf8");
+    }
+    catch {
+        // Best-effort: if the directory is read-only, a reinstall applies. Never
+        // block activation over it.
+    }
+}
+/** VSCode entry point. Binds the live API to the host and starts the shell. */
+function activate(context) {
+    // Resolve `vscode` lazily so the package builds and tests without it present.
+    const vscode = (0, node_module_1.createRequire)(__filename)("vscode");
+    ensureTsserverPluginModule();
+    const host = createHost(vscode);
+    let definitions;
+    const profileController = new profile_state_js_1.ProfileStateController(host);
+    const presentation = new macro_presentation_js_1.MacroPresentationController(host, () => definitions);
+    const packageProfile = new package_profile_js_1.PackageProfileController(host, profileController, (next) => {
+        definitions = next;
+        presentation.refresh();
+    });
+    profileController.activate();
+    presentation.activate();
+    packageProfile.activate();
+    const subscriptions = [
+        vscode.workspace.onDidChangeTextDocument((event) => presentation.refreshDocument(toSnapshot(event.document))),
+        vscode.workspace.onDidOpenTextDocument((document) => presentation.refreshDocument(toSnapshot(document))),
+        vscode.workspace.onDidCloseTextDocument((document) => presentation.closeDocument(document.uri.toString())),
+        vscode.window.onDidChangeVisibleTextEditors(() => presentation.refresh()),
+    ];
+    active = {
+        profileController,
+        presentation,
+        packageProfile,
+        dispose: () => {
+            for (const subscription of subscriptions) {
+                subscription.dispose();
+            }
+            presentation.dispose();
+            packageProfile.dispose();
+            profileController.dispose();
+        },
+    };
+    context.subscriptions.push({ dispose: () => deactivate() });
+}
+/** VSCode shutdown hook. */
+function deactivate() {
+    active?.dispose();
+    active = undefined;
+}
+//# sourceMappingURL=extension.js.map

package/dist/vscode/host.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Minimal, injectable surface of the VSCode API used by the extension shell.
+ *
+ * The shell depends only on this interface so its logic runs under the standard
+ * Node test runner without the VSCode extension host. `src/vscode/extension.ts`
+ * binds the real `vscode` module to this surface at activation time.
+ */
+import type { DocumentDiagnostic, DocumentRange, FoldingRange } from "./document-analysis.js";
+export interface Disposable {
+    dispose(): void;
+}
+/** Subset of `vscode.StatusBarItem`. */
+export interface StatusBarItem extends Disposable {
+    text: string;
+    tooltip: string | undefined;
+    command: string | undefined;
+    show(): void;
+    hide(): void;
+}
+/** An open macro document the presentation layer must keep in sync. */
+export interface DocumentSnapshot {
+    /** Stable document identity (its URI string in the real host). */
+    readonly uri: string;
+    /** Whether this document holds macro-bearing TypeScript-family source. */
+    readonly isMacroDocument: boolean;
+    /** The current in-memory text, including unsaved edits. */
+    getText(): string;
+}
+/** Subset of `vscode.DiagnosticCollection`. */
+export interface DiagnosticCollection extends Disposable {
+    set(uri: string, diagnostics: readonly DocumentDiagnostic[]): void;
+    delete(uri: string): void;
+    clear(): void;
+}
+/** Opaque handle for a decoration style; maps to `vscode.TextEditorDecorationType`. */
+export interface DecorationType extends Disposable {
+    readonly key: string;
+}
+/** Provides folding ranges for one macro document, given its current text. */
+export type FoldingRangeProvider = (document: DocumentSnapshot) => readonly FoldingRange[];
+/**
+ * The capabilities the extension shell needs from its host. Every method maps
+ * directly onto a real `vscode` API call in the activation adapter.
+ */
+export interface ExtensionHost {
+    /** Create a left-aligned status-bar item. */
+    createStatusBarItem(): StatusBarItem;
+    /** Register a command handler, returning its disposable. */
+    registerCommand(command: string, handler: () => unknown | Promise<unknown>): Disposable;
+    /** Surface a non-blocking informational message. */
+    showInformationMessage(message: string): void;
+    /** The first workspace folder's filesystem path, if any. */
+    workspaceRoot(): string | undefined;
+    /** Create the diagnostic collection that owns published macro diagnostics. */
+    createDiagnosticCollection(name: string): DiagnosticCollection;
+    /** Create the inactive-code decoration style applied to grayed ranges. */
+    createInactiveDecorationType(): DecorationType;
+    /** Apply a decoration's ranges to a document; an empty list clears them. */
+    setDecorations(uri: string, decoration: DecorationType, ranges: readonly DocumentRange[]): void;
+    /** Every currently open macro document. */
+    macroDocuments(): readonly DocumentSnapshot[];
+    /** Register a folding-range provider for macro documents. */
+    registerFoldingRangeProvider(provider: FoldingRangeProvider): Disposable;
+    /** Surface a non-blocking error message. */
+    showErrorMessage(message: string): void;
+    /** Send live configuration to the contributed TypeScript server plugin. */
+    configureTypeScriptPlugin(name: string, configuration: Readonly<Record<string, unknown>>): Promise<void>;
+    /**
+     * Restart the TypeScript server after the effective Profile changes.
+     * Reloading projects is not sufficient to clear stale language-service
+     * diagnostics in every workspace.
+     */
+    restartTypeScriptServer(): Promise<void>;
+    /** Reload projects after the restarted server has received plugin config. */
+    reloadTypeScriptProjects(): Promise<void>;
+    /** Watch package.json and Profile JSON files that determine editor semantics. */
+    watchProjectConfiguration(onChange: () => void): Disposable;
+}
+//# sourceMappingURL=host.d.ts.map

package/dist/vscode/host.js

@@ -0,0 +1,16 @@
+"use strict";
+// Copyright (C) 2026 Tencent. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=host.js.map

package/dist/vscode/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./host.js";
+export * from "./document-analysis.js";
+export * from "./profile-state.js";
+export * from "./macro-presentation.js";
+export * from "./package-profile.js";
+export * from "./extension.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/vscode/index.js

@@ -0,0 +1,36 @@
+"use strict";
+// Copyright (C) 2026 Tencent. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./host.js"), exports);
+__exportStar(require("./document-analysis.js"), exports);
+__exportStar(require("./profile-state.js"), exports);
+__exportStar(require("./macro-presentation.js"), exports);
+__exportStar(require("./package-profile.js"), exports);
+__exportStar(require("./extension.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/vscode/macro-presentation.d.ts

@@ -0,0 +1,43 @@
+import type { MacroDefinitions } from "../core/expression.js";
+import type { DocumentSnapshot, ExtensionHost } from "./host.js";
+/** Name of the diagnostic collection contributed by the extension. */
+export declare const diagnosticCollectionName: "tsifdef";
+/**
+ * Resolves the macro definitions for the currently effective Profile, or
+ * `undefined` when no Profile is selected. Returning a value is synchronous so
+ * the controller can refresh without awaiting I/O; the extension caches the
+ * loaded Profile and updates it on switch.
+ */
+export type DefinitionsProvider = () => MacroDefinitions | undefined;
+/**
+ * Publishes macro diagnostics and grays out inactive ranges for open macro
+ * documents.
+ *
+ * It reuses the shared core through `analyzeDocument` and depends only on the
+ * injected host, so it runs without the VSCode extension host.
+ */
+export declare class MacroPresentationController {
+    private readonly host;
+    private readonly definitionsProvider;
+    private diagnostics;
+    private inactiveDecoration;
+    private readonly decoratedDocuments;
+    private readonly disposables;
+    constructor(host: ExtensionHost, definitionsProvider: DefinitionsProvider);
+    /** Create the diagnostic collection and decoration style, then render once. */
+    activate(): void;
+    dispose(): void;
+    /** Recompute diagnostics and decorations for every open macro document. */
+    refresh(): void;
+    /** Refresh a single document, e.g. on edit or open. */
+    refreshDocument(document: DocumentSnapshot): void;
+    /** Clear diagnostics and decorations for a closed document. */
+    closeDocument(uri: string): void;
+    /** Folding ranges for one macro document under the effective Profile. */
+    foldingRanges(document: DocumentSnapshot): readonly import("./document-analysis.js").FoldingRange[];
+    private render;
+    private clear;
+    private clearDocument;
+    private clearDocumentDecoration;
+}
+//# sourceMappingURL=macro-presentation.d.ts.map

package/dist/vscode/macro-presentation.js

@@ -0,0 +1,130 @@
+"use strict";
+// Copyright (C) 2026 Tencent. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MacroPresentationController = exports.diagnosticCollectionName = void 0;
+const document_analysis_js_1 = require("./document-analysis.js");
+/** Name of the diagnostic collection contributed by the extension. */
+exports.diagnosticCollectionName = "tsifdef";
+/**
+ * Publishes macro diagnostics and grays out inactive ranges for open macro
+ * documents.
+ *
+ * It reuses the shared core through `analyzeDocument` and depends only on the
+ * injected host, so it runs without the VSCode extension host.
+ */
+class MacroPresentationController {
+    host;
+    definitionsProvider;
+    diagnostics;
+    inactiveDecoration;
+    decoratedDocuments = new Set();
+    disposables = [];
+    constructor(host, definitionsProvider) {
+        this.host = host;
+        this.definitionsProvider = definitionsProvider;
+    }
+    /** Create the diagnostic collection and decoration style, then render once. */
+    activate() {
+        this.diagnostics = this.host.createDiagnosticCollection(exports.diagnosticCollectionName);
+        this.inactiveDecoration = this.host.createInactiveDecorationType();
+        this.disposables.push(this.diagnostics, this.inactiveDecoration);
+        this.disposables.push(this.host.registerFoldingRangeProvider((document) => this.foldingRanges(document)));
+        this.refresh();
+    }
+    dispose() {
+        for (const disposable of this.disposables.splice(0).reverse()) {
+            disposable.dispose();
+        }
+        this.decoratedDocuments.clear();
+        this.diagnostics = undefined;
+        this.inactiveDecoration = undefined;
+    }
+    /** Recompute diagnostics and decorations for every open macro document. */
+    refresh() {
+        if (this.diagnostics === undefined) {
+            return;
+        }
+        const definitions = this.definitionsProvider();
+        if (definitions === undefined) {
+            this.clear();
+            return;
+        }
+        const live = new Set();
+        for (const document of this.host.macroDocuments()) {
+            if (!document.isMacroDocument) {
+                continue;
+            }
+            live.add(document.uri);
+            this.render(document, definitions);
+        }
+        // Drop documents that closed or stopped being macro documents since last run.
+        for (const uri of [...this.decoratedDocuments]) {
+            if (!live.has(uri)) {
+                this.clearDocument(uri);
+            }
+        }
+    }
+    /** Refresh a single document, e.g. on edit or open. */
+    refreshDocument(document) {
+        if (this.diagnostics === undefined) {
+            return;
+        }
+        const definitions = this.definitionsProvider();
+        if (definitions === undefined || !document.isMacroDocument) {
+            this.clearDocument(document.uri);
+            return;
+        }
+        this.render(document, definitions);
+    }
+    /** Clear diagnostics and decorations for a closed document. */
+    closeDocument(uri) {
+        this.clearDocument(uri);
+    }
+    /** Folding ranges for one macro document under the effective Profile. */
+    foldingRanges(document) {
+        const definitions = this.definitionsProvider();
+        if (definitions === undefined || !document.isMacroDocument) {
+            return [];
+        }
+        return (0, document_analysis_js_1.computeFoldingRanges)(document.getText(), definitions);
+    }
+    render(document, definitions) {
+        const analysis = (0, document_analysis_js_1.analyzeDocument)(document.getText(), definitions);
+        this.diagnostics?.set(document.uri, analysis.diagnostics);
+        if (this.inactiveDecoration !== undefined) {
+            this.host.setDecorations(document.uri, this.inactiveDecoration, analysis.inactiveRanges);
+        }
+        this.decoratedDocuments.add(document.uri);
+    }
+    clear() {
+        this.diagnostics?.clear();
+        for (const uri of [...this.decoratedDocuments]) {
+            this.clearDocumentDecoration(uri);
+        }
+        this.decoratedDocuments.clear();
+    }
+    clearDocument(uri) {
+        this.diagnostics?.delete(uri);
+        this.clearDocumentDecoration(uri);
+        this.decoratedDocuments.delete(uri);
+    }
+    clearDocumentDecoration(uri) {
+        if (this.inactiveDecoration !== undefined) {
+            this.host.setDecorations(uri, this.inactiveDecoration, []);
+        }
+    }
+}
+exports.MacroPresentationController = MacroPresentationController;
+//# sourceMappingURL=macro-presentation.js.map

package/dist/vscode/package-profile.d.ts

@@ -0,0 +1,27 @@
+import type { MacroDefinitions } from "../core/expression.js";
+import type { Disposable, ExtensionHost } from "./host.js";
+import { ProfileStateController } from "./profile-state.js";
+/** Watches the package-owned Profile pointer and synchronizes all editor consumers. */
+export declare class PackageProfileController implements Disposable {
+    private readonly host;
+    private readonly state;
+    private readonly onDefinitions;
+    private watcher;
+    private debounceTimer;
+    private appliedIdentity;
+    private initialized;
+    constructor(host: ExtensionHost, state: ProfileStateController, onDefinitions: (definitions: MacroDefinitions | undefined) => void);
+    activate(): void;
+    dispose(): void;
+    private scheduleReload;
+    reload(): Promise<void>;
+    private applyTypeScriptProfile;
+    /**
+     * Load the Profile, retrying a few times on a transient failure. An atomic
+     * writer (temp file + rename) briefly leaves the path missing; reacting to
+     * that momentary miss made the Profile flap to "none" and back, restarting
+     * the server in a loop.
+     */
+    private loadProfileWithRetry;
+}
+//# sourceMappingURL=package-profile.d.ts.map