extension-develop 4.1.17 → 4.1.18-canary.1789403792.e514b06c

package/dist/950~0.mjs

@@ -89,6 +89,29 @@ function buildComplete(browser, distDisplayPath, totalBytes) {
 function platformDocsUrl() {
     return String(process.env.EXTENSION_DEV_DOCS_URL || '').trim().replace(/\/+$/, '');
 }
+function pluralize(count, noun) {
+    return `${count} ${noun}${1 === count ? '' : 's'}`;
+}
+function addonLintSummary(errorCount, warningCount, distDisplay) {
+    const parts = [];
+    if (errorCount > 0) parts.push(pluralize(errorCount, 'error'));
+    if (warningCount > 0) parts.push(pluralize(warningCount, 'warning'));
+    return `${getLoggingPrefix('warn')} Store check for addons.mozilla.org: addons-linter found ${parts.join(' and ')} in ${pintor.underline(distDisplay)}`;
+}
+function addonLintFinding(level, code, message, location) {
+    const glyph = getLoggingPrefix('error' === level ? 'warn' : 'info');
+    const where = location ? ` ${pintor.gray(`(${location})`)}` : '';
+    return `${glyph} AMO ${level} ${pintor.yellow(code)}: ${message}${where}`;
+}
+function addonLintMore(hiddenCount, distDisplay) {
+    return `${getLoggingPrefix('info')} ${pluralize(hiddenCount, 'more finding')} not shown. Run ${pintor.blue(`npx addons-linter ${distDisplay}`)} for the full report.`;
+}
+function addonLintNotInstalled(installHint) {
+    return `${getLoggingPrefix('info')} Skipped the addons.mozilla.org lint: addons-linter is not installed. Install it with: ${pintor.blue(installHint)} or pass ${pintor.blue('--no-addon-lint')} to silence this.`;
+}
+function addonLintFailed(reason) {
+    return `${getLoggingPrefix('debug')} addon-lint skipped=true reason="${reason}"`;
+}
 function buildShareHint() {
     const docs = platformDocsUrl();
     if (!docs) return '';
@@ -932,4 +955,4 @@ function actionsPath(projectPath, browser) {
 function buildSummaryPath(projectPath, browser) {
     return __rspack_external_node_path_806ed179.join(browserArtifactsDir(projectPath, browser), 'build-summary.json');
 }
-export { actionsPath, anotherDevSessionActive, asAbsolute, authorInstallNotice, browserArtifactsDir, browserDistDir, browserLaunchFailed, browserProfileRootDir, buildAssetsTree, buildCommandFailed, buildComplete, buildFailed, buildShareHint, buildSummaryPath, buildWarningsDetails, computePreviewOutputPath, configBrowserOrThrow, configLoadingError, controlPortFilePath, controlTokenPath, debugBrowser, debugContextPath, debugDirs, debugExtensionsToLoad, debugOutputPath, debugPreviewOutput, debugSplitChunksNarrowed, devCommandFailed, devtoolsEngineFor, downloadingText, ensureSessionArtifactsIgnoreFile, ensureSessionStateInProjectGitignore, eventsPath, extensionLoadRecovered, extensionLoadStillRefused, failedToDownloadOrExtractZIPFileError, getDirs, getDistPath, getProjectStructure, invalidRemoteZip, isUsingExperimentalConfig, legacyControlPortFilePath, legacyControlTokenPath, localZipNotFound, logsPath, managedDependencyConflict, manifestInvalidJson, needsInstall, noCompanionExtensionsResolved, normalizeBrowser, notAZipArchive, packagingDistributionFiles, packagingSourceFiles, previewing, previewingCustomOutput, previewingSourceFallback, projectInstallFallbackToNpm, projectInstallScriptsDisabled, readyContractPath, resolveProjectStructureSync, sessionArtifactsRootDir, sessionStateDir, starting, toPosixPath, treeWithDistFilesBrowser, treeWithSourceAndDistFiles, treeWithSourceFiles, unpackagedSuccessfully, unpackagingExtension, writingTypeDefinitions, writingTypeDefinitionsError, zipArtifactReady };
+export { actionsPath, addonLintFailed, addonLintFinding, addonLintMore, addonLintNotInstalled, addonLintSummary, anotherDevSessionActive, asAbsolute, authorInstallNotice, browserArtifactsDir, browserDistDir, browserLaunchFailed, browserProfileRootDir, buildAssetsTree, buildCommandFailed, buildComplete, buildFailed, buildShareHint, buildSummaryPath, buildWarningsDetails, computePreviewOutputPath, configBrowserOrThrow, configLoadingError, controlPortFilePath, controlTokenPath, debugBrowser, debugContextPath, debugDirs, debugExtensionsToLoad, debugOutputPath, debugPreviewOutput, debugSplitChunksNarrowed, devCommandFailed, devtoolsEngineFor, downloadingText, ensureSessionArtifactsIgnoreFile, ensureSessionStateInProjectGitignore, eventsPath, extensionLoadRecovered, extensionLoadStillRefused, failedToDownloadOrExtractZIPFileError, getDirs, getDistPath, getProjectStructure, invalidRemoteZip, isUsingExperimentalConfig, legacyControlPortFilePath, legacyControlTokenPath, localZipNotFound, logsPath, managedDependencyConflict, manifestInvalidJson, needsInstall, noCompanionExtensionsResolved, normalizeBrowser, notAZipArchive, packagingDistributionFiles, packagingSourceFiles, previewing, previewingCustomOutput, previewingSourceFallback, projectInstallFallbackToNpm, projectInstallScriptsDisabled, readyContractPath, resolveProjectStructureSync, sessionArtifactsRootDir, sessionStateDir, starting, toPosixPath, treeWithDistFilesBrowser, treeWithSourceAndDistFiles, treeWithSourceFiles, unpackagedSuccessfully, unpackagingExtension, writingTypeDefinitions, writingTypeDefinitionsError, zipArtifactReady };

package/dist/lib/addon-lint.d.ts

@@ -0,0 +1,71 @@
+export declare const ADDON_LINT_DEFAULT = true;
+export declare const ADDON_LINT_TIMEOUT_MS = 10000;
+export declare const ADDON_LINT_MAX_PRINTED = 20;
+export declare const ADDON_LINT_PACKAGE = "addons-linter";
+export interface AddonLintFinding {
+    code?: string;
+    message?: string;
+    description?: string;
+    file?: string;
+    line?: number;
+    column?: number;
+}
+export interface AddonLintOutput {
+    errors?: AddonLintFinding[];
+    warnings?: AddonLintFinding[];
+    notices?: AddonLintFinding[];
+}
+export type AddonLintLevel = 'error' | 'warning';
+export interface AddonLintLine {
+    level: AddonLintLevel;
+    code: string;
+    message: string;
+    location: string;
+}
+export type AddonLintResult = {
+    status: 'skipped';
+    reason: 'disabled' | 'mode' | 'browser';
+} | {
+    status: 'missing';
+    hint: string | null;
+} | {
+    status: 'failed';
+    debugLine: string;
+} | {
+    status: 'linted';
+    findings: number;
+    lines: string[];
+};
+type LinterModule = {
+    createInstance: (options: {
+        config: Record<string, unknown>;
+        runAsBinary: boolean;
+    }) => {
+        run: (deps?: Record<string, unknown>) => Promise<AddonLintOutput>;
+    };
+};
+export type LoadAddonLinter = (projectPath: string) => Promise<LinterModule>;
+export interface RunAddonLintInput {
+    projectPath: string;
+    distPath: string;
+    distDisplay: string;
+    browser: string;
+    mode: 'development' | 'production' | 'none';
+    enabled?: boolean;
+    loadLinter?: LoadAddonLinter;
+    timeoutMs?: number;
+}
+export declare function shouldRunAddonLint(input: {
+    browser: string;
+    mode: RunAddonLintInput['mode'];
+    enabled?: boolean;
+}): Extract<AddonLintResult, {
+    status: 'skipped';
+}> | null;
+export declare function collectAddonLintLines(output: AddonLintOutput | null | undefined): AddonLintLine[];
+export declare function formatAddonLintFindings(output: AddonLintOutput | null | undefined, distDisplay: string, maxPrinted?: number): {
+    findings: number;
+    lines: string[];
+};
+export declare function runAddonLint(input: RunAddonLintInput): Promise<AddonLintResult>;
+export {};

package/dist/lib/merge-options.d.ts

@@ -18,6 +18,7 @@ export declare const BUILD_COMMAND_DEFAULTS: {
     zip: boolean;
     zipSource: boolean;
     silent: boolean;
+    addonLint: boolean;
 };
 /**
  * Stock defaults for the `extension start` / `extension preview` browser
@@ -37,6 +38,7 @@ export declare const SERVE_COMMAND_DEFAULTS: {
 export declare const START_BUILD_DEFAULTS: {
     polyfill: boolean;
     silent: boolean;
+    addonLint: boolean;
 };
 /**
  * Array-valued option keys that concatenate across layers (browser config,

package/dist/lib/messages.d.ts

@@ -19,6 +19,11 @@ export declare function projectInstallScriptsDisabled(pmName: string): string;
 export declare function anotherDevSessionActive(browser: string, pid: number, runId: string): string;
 export declare function buildAssetsTree(stats: Stats | undefined): string;
 export declare function buildComplete(browser: DevOptions['browser'], distDisplayPath: string, totalBytes?: number): string;
+export declare function addonLintSummary(errorCount: number, warningCount: number, distDisplay: string): string;
+export declare function addonLintFinding(level: 'error' | 'warning', code: string, message: string, location: string): string;
+export declare function addonLintMore(hiddenCount: number, distDisplay: string): string;
+export declare function addonLintNotInstalled(installHint: string): string;
+export declare function addonLintFailed(reason: string): string;
 export declare function buildShareHint(): string;
 export declare function buildFailed(errorCount: number): string;
 type LooseBuildWarning = string | null | undefined | {

package/dist/lib/optional-deps-resolver.d.ts

@@ -1,4 +1,5 @@
 import type { OptionalDependencyContract } from './optional-dependency-types.js';
+export declare function formatInstallHint(projectPath: string, packageSpecs: string[]): string;
 type EnsureResolveInput = {
     integration: string;
     projectPath: string;

package/dist/rspack-config~0.mjs

@@ -14,10 +14,10 @@ import node_path from "node:path";
 import { utils_isUrl, getBaseNode, parseHtml, manifestJsonOutputTarget, getExtname, getBaseHref, isResourceUnderDirs, getAssetsFromHtml, normalizeManifestOutputPath, manifestPageOutputTarget, canonicalizeDir, iconOutputPath, isFromIncludeList, htmlStaticAssetOutputName, isSpecialScheme, resolveStaticAttributeName, getHtmlPageDeclaredAssetPath, themeImageOutputPath, themeIconOutputPath, applyRewrittenStaticUrl, toResourceKey, cleanLeading, getFilePath, resolveAbsoluteFsPath, cleanAssetUrl, isHttpLike, resolveHtmlRefPath } from "./938~0.mjs";
 import { prefix as messaging_prefix, isDebug } from "./852~0.mjs";
 import { isChromiumBasedBrowser, CHROMIUM_FAMILY_ALIASES, GECKO_FAMILY_ALIASES, isWebkitBasedBrowser, isGeckoBasedBrowser } from "./331~0.mjs";
-import { isUsingTypeScript, resolvePackageManager, jsFrameworksIntegrationsEnabled, classifyEntrySurface, ensureTypeScriptConfig, resolveDevelopInstallRoot, isUsingCustomLoader, getUserTypeScriptConfigFile, isUsingIntegration as messages_isUsingIntegration, jsFrameworksHmrSummary, humanLine, jsFrameworksConfigsDetected, recordZipArtifact, hasDependency, resolveDevelopDistFile, defaultSplitChunks } from "./840~0.mjs";
-import { package_namespaceObject, bundlerFatalError, bundlerRecompiling, browserRunnerDisabled, PlaywrightPlugin, publicFolderShadowed, resolveCompanionExtensionDirs, specialFoldersSetupSummary, noEntrypointsDetected, serverRestartRequiredFromSpecialFolderMessageOnly, specialFolderChangeDetected, spacerLine, messages_ready, getPreloadedEnvKeys, publicMustBeAtProjectRoot, computeExtensionsToLoad, getSpecialFoldersDataForCompiler } from "./832~0.mjs";
+import { isUsingTypeScript, jsFrameworksIntegrationsEnabled, classifyEntrySurface, ensureTypeScriptConfig, ensureOptionalContractModuleLoaded, resolveDevelopInstallRoot, isUsingCustomLoader, getUserTypeScriptConfigFile, loadOptionalContractModuleWithoutInstall, isUsingIntegration as messages_isUsingIntegration, resolveOptionalContractPackageWithoutInstall, jsFrameworksHmrSummary, humanLine, ensureOptionalContractPackageResolved, jsFrameworksConfigsDetected, recordZipArtifact, hasDependency, resolveDevelopDistFile, defaultSplitChunks } from "./840~0.mjs";
+import { bundlerFatalError, bundlerRecompiling, browserRunnerDisabled, PlaywrightPlugin, publicFolderShadowed, resolveCompanionExtensionDirs, specialFoldersSetupSummary, noEntrypointsDetected, serverRestartRequiredFromSpecialFolderMessageOnly, specialFolderChangeDetected, spacerLine, messages_ready, getPreloadedEnvKeys, publicMustBeAtProjectRoot, computeExtensionsToLoad, getSpecialFoldersDataForCompiler } from "./832~0.mjs";
 import { renderStatsBlocks, makeSanitizedConsole } from "./stats-handler~0.mjs";
-import { stripBom, hasProjectDependency, findNearestProjectManifestSync, PROJECT_MANIFEST_FILENAMES, parseJsonSafe, readProjectDependencies } from "./731~0.mjs";
+import { stripBom, findNearestProjectManifestSync, PROJECT_MANIFEST_FILENAMES, parseJsonSafe, readProjectDependencies } from "./731~0.mjs";
 import { EXTENSIONJS_CONTENT_SCRIPT_LAYER, getCanonicalContentScriptEntryName, parseCanonicalContentScriptAsset, CONTENT_SCRIPT_CSS_PROBE_MARKER_PREFIX, createContentScriptCssProbeMarkerPattern, getCanonicalContentScriptJsAssetName, getCanonicalContentScriptCssAssetName, isCanonicalContentScriptAsset } from "./640~0.mjs";
 import { getURLDependencyMissing, entrySplitAcrossInitialFiles, isStaticThemeSource, fetchedFileDependencyMissing, isStaticTheme, importScriptsDependencyMissing, filterKeysForThisBrowser, injectedCompiledSourceLiteral, injectedFileDependencyMissing, staticImportDependencyMissing, runtimeSetSurfaceDependencyMissing } from "./672~0.mjs";
 import { packagingSourceFiles, debugBrowser, debugExtensionsToLoad, treeWithSourceFiles, debugOutputPath, manifestInvalidJson, getDirs, asAbsolute, treeWithDistFilesBrowser, packagingDistributionFiles, treeWithSourceAndDistFiles, toPosixPath as paths_toPosixPath, debugContextPath, noCompanionExtensionsResolved } from "./950~0.mjs";
@@ -1558,519 +1558,6 @@ class CompilationPlugin {
         if ('build' !== this.command && 'start' !== this.command) setupCompilerDoneDiagnostics(compiler, this.port);
     }
 }
-const BUNDLED_DEPENDENCY_VERSIONS = {
-    ...package_namespaceObject.El || {}
-};
-function optional_deps_contracts_spec(packageId) {
-    const version = BUNDLED_DEPENDENCY_VERSIONS[packageId];
-    return version ? `${packageId}@${version}` : packageId;
-}
-function specs(packageIds) {
-    return packageIds.map(optional_deps_contracts_spec);
-}
-function installRootRules(packageIds) {
-    return packageIds.map((packageId)=>({
-            type: 'install-root',
-            packageId
-        }));
-}
-function defineContract(contract) {
-    return contract;
-}
-const OPTIONAL_DEPENDENCY_CONTRACTS = {
-    'react-refresh': defineContract({
-        id: 'react-refresh',
-        integration: 'React',
-        installPackages: specs([
-            'react-refresh',
-            '@rspack/plugin-react-refresh'
-        ]),
-        verificationRules: [
-            ...installRootRules([
-                'react-refresh',
-                '@rspack/plugin-react-refresh'
-            ]),
-            {
-                type: 'module-context-resolve',
-                fromPackage: '@rspack/plugin-react-refresh',
-                packageId: 'react-refresh'
-            }
-        ]
-    }),
-    'preact-refresh': defineContract({
-        id: 'preact-refresh',
-        integration: 'Preact',
-        installPackages: specs([
-            '@prefresh/core',
-            '@prefresh/utils',
-            '@rspack/plugin-preact-refresh',
-            'preact'
-        ]),
-        verificationRules: [
-            ...installRootRules([
-                '@prefresh/core',
-                '@prefresh/utils',
-                '@rspack/plugin-preact-refresh',
-                'preact'
-            ]),
-            {
-                type: 'module-context-resolve',
-                fromPackage: '@rspack/plugin-preact-refresh',
-                packageId: '@prefresh/core'
-            },
-            {
-                type: 'module-context-resolve',
-                fromPackage: '@rspack/plugin-preact-refresh',
-                packageId: '@prefresh/utils'
-            },
-            {
-                type: 'module-context-resolve',
-                fromPackage: '@rspack/plugin-preact-refresh',
-                packageId: 'preact'
-            }
-        ]
-    }),
-    vue: defineContract({
-        id: 'vue',
-        integration: 'Vue',
-        installPackages: specs([
-            'vue-loader',
-            '@vue/compiler-sfc',
-            'vue'
-        ]),
-        verificationRules: [
-            ...installRootRules([
-                'vue-loader',
-                '@vue/compiler-sfc',
-                'vue'
-            ]),
-            {
-                type: 'module-context-load',
-                fromPackage: 'vue-loader',
-                packageId: '@vue/compiler-sfc'
-            }
-        ]
-    }),
-    svelte: defineContract({
-        id: 'svelte',
-        integration: 'Svelte',
-        installPackages: specs([
-            'svelte-loader'
-        ]),
-        verificationRules: installRootRules([
-            'svelte-loader'
-        ])
-    }),
-    less: defineContract({
-        id: 'less',
-        integration: 'LESS',
-        installPackages: specs([
-            'less',
-            'less-loader'
-        ]),
-        verificationRules: installRootRules([
-            'less',
-            'less-loader'
-        ])
-    }),
-    postcss: defineContract({
-        id: 'postcss',
-        integration: 'PostCSS',
-        installPackages: specs([
-            'postcss',
-            'postcss-loader'
-        ]),
-        verificationRules: installRootRules([
-            'postcss',
-            'postcss-loader'
-        ])
-    }),
-    sass: defineContract({
-        id: 'sass',
-        integration: 'SASS',
-        installPackages: specs([
-            'postcss-loader',
-            'postcss-scss',
-            'postcss-preset-env',
-            'sass-loader'
-        ]),
-        verificationRules: installRootRules([
-            'postcss-loader',
-            'postcss-scss',
-            'postcss-preset-env',
-            'sass-loader'
-        ])
-    })
-};
-function getOptionalDependencyContract(contractId) {
-    const contract = OPTIONAL_DEPENDENCY_CONTRACTS[contractId];
-    if (!contract) throw new Error(`Unknown optional dependency contract: ${contractId}`);
-    return contract;
-}
-function debugSwallowed(step, error) {
-    if (!isVerboseMode()) return;
-    console.log(`${messaging_prefix('debug')} optional-deps ${step}: ${String(error?.message || error)}`);
-}
-function isVerboseMode() {
-    return '1' === String(process.env.EXTENSION_VERBOSE || '').trim();
-}
-function installVerbForPackageManager(name) {
-    if ('npm' === name) return 'install -D';
-    if ('deno' === name) return 'add --dev';
-    return 'add -D';
-}
-function formatInstallHint(projectPath, packageSpecs) {
-    const { name } = resolvePackageManager({
-        cwd: projectPath
-    });
-    const verb = installVerbForPackageManager(name);
-    return `${name} ${verb} ${packageSpecs.join(' ')}`;
-}
-function formatResolverError(args) {
-    const hint = formatInstallHint(args.projectPath, args.installSpecs);
-    const readableLine = `[${args.integration}] ${args.headline} Install it with: ${hint}`;
-    if (!isVerboseMode()) return readableLine;
-    return `${readableLine}\n${JSON.stringify(args.diagnostics, null, 2)}`;
-}
-function toInstallRootContract(integration, contractId, installDependencies, verifyPackageIds) {
-    return {
-        id: contractId,
-        integration,
-        installPackages: installDependencies,
-        verificationRules: verifyPackageIds.map((packageId)=>({
-                type: 'install-root',
-                packageId
-            }))
-    };
-}
-function getVerificationContract(input) {
-    if (input.contract) return input.contract;
-    const installDependencies = input.installDependencies || [
-        input.dependencyId
-    ];
-    const verifyPackageIds = input.verifyPackageIds || installDependencies;
-    return toInstallRootContract(input.integration, input.integration, installDependencies, verifyPackageIds);
-}
-function getResolutionBases(projectPath) {
-    const extensionRoot = resolveDevelopInstallRoot();
-    const bases = [
-        projectPath,
-        extensionRoot || void 0,
-        process.cwd()
-    ].filter(Boolean);
-    if (extensionRoot?.includes('.pnpm')) bases.push(__rspack_external_node_path_806ed179.join(extensionRoot, '..', '..'));
-    return Array.from(new Set(bases));
-}
-function optional_deps_resolver_packageJsonPath(basePath) {
-    return __rspack_external_node_path_806ed179.join(basePath, 'package.json');
-}
-function tryResolveWithBase(dependencyId, basePath) {
-    try {
-        const req = createRequire(optional_deps_resolver_packageJsonPath(basePath));
-        return req.resolve(dependencyId);
-    } catch (error) {
-        debugSwallowed(`resolve ${dependencyId} from ${basePath}`, error);
-        return;
-    }
-}
-function resolveDependency(dependencyId, projectPath) {
-    const bases = getResolutionBases(projectPath);
-    for (const basePath of bases){
-        const resolvedPath = tryResolveWithBase(dependencyId, basePath);
-        if (resolvedPath) return {
-            resolvedPath,
-            basePath
-        };
-    }
-    try {
-        const resolvedPath = require.resolve(dependencyId, {
-            paths: bases
-        });
-        return {
-            resolvedPath,
-            basePath: projectPath
-        };
-    } catch (error) {
-        debugSwallowed(`resolve ${dependencyId} from the project bases`, error);
-        return;
-    }
-}
-function resolveFromKnownLocations(dependencyId, projectPath) {
-    const direct = resolveDependency(dependencyId, projectPath)?.resolvedPath;
-    if (direct) return direct;
-    if (declaresDependency(projectPath, dependencyId)) return projectPath;
-}
-function declaresDependency(projectPath, dependencyId) {
-    try {
-        return hasProjectDependency(projectPath, dependencyId);
-    } catch (error) {
-        debugSwallowed(`read the project manifest for ${dependencyId}`, error);
-        return false;
-    }
-}
-function dedupeFailures(packageIds) {
-    return Array.from(new Set(packageIds));
-}
-function resolveRealPathSafe(targetPath) {
-    try {
-        return __rspack_external_node_fs_1b05aee1.realpathSync(targetPath);
-    } catch (error) {
-        debugSwallowed(`realpath ${targetPath}`, error);
-        return __rspack_external_node_path_806ed179.resolve(targetPath);
-    }
-}
-function findOwningPackageDir(resolvedPath) {
-    let currentPath = __rspack_external_node_path_806ed179.dirname(resolvedPath);
-    for(let depth = 0; depth < 8; depth++){
-        const packageJson = __rspack_external_node_path_806ed179.join(currentPath, 'package.json');
-        if (__rspack_external_node_fs_1b05aee1.existsSync(packageJson)) return currentPath;
-        const parent = __rspack_external_node_path_806ed179.dirname(currentPath);
-        if (parent === currentPath) break;
-        currentPath = parent;
-    }
-}
-function isSameInstalledPackage(resolvedPath, expectedInstalledPath) {
-    const resolvedPackageDir = findOwningPackageDir(resolvedPath);
-    const expectedPackageDir = findOwningPackageDir(expectedInstalledPath);
-    if (resolvedPackageDir && expectedPackageDir) return resolveRealPathSafe(resolvedPackageDir) === resolveRealPathSafe(expectedPackageDir);
-    return resolveRealPathSafe(resolvedPath) === resolveRealPathSafe(expectedInstalledPath);
-}
-function evaluateModuleContextRule(rule, fromPackagePath, options) {
-    try {
-        const req = createRequire(fromPackagePath);
-        const resolvedPeer = req.resolve(rule.packageId);
-        if (options?.expectedInstalledPath && !isSameInstalledPackage(resolvedPeer, options.expectedInstalledPath)) return rule.packageId;
-        if ('module-context-load' === rule.type) req(rule.packageId);
-        return;
-    } catch (error) {
-        debugSwallowed(`verify ${rule.packageId}`, error);
-        return rule.packageId;
-    }
-}
-function getContractVerificationFailuresFromKnownLocations(contract, projectPath) {
-    const resolvedByPackage = new Map();
-    const resolvePackage = (packageId)=>{
-        if (!resolvedByPackage.has(packageId)) resolvedByPackage.set(packageId, resolveFromKnownLocations(packageId, projectPath));
-        return resolvedByPackage.get(packageId);
-    };
-    const failures = [];
-    for (const rule of contract.verificationRules){
-        if ('install-root' === rule.type) {
-            if (!resolvePackage(rule.packageId)) failures.push(rule.packageId);
-            continue;
-        }
-        const fromPackagePath = resolvePackage(rule.fromPackage);
-        if (!fromPackagePath) {
-            failures.push(rule.fromPackage);
-            continue;
-        }
-        const failure = evaluateModuleContextRule(rule, fromPackagePath);
-        if (!(failure && declaresDependency(projectPath, failure))) {
-            if (failure) failures.push(failure);
-        }
-    }
-    return dedupeFailures(failures);
-}
-function buildDiagnostics(input) {
-    const bases = getResolutionBases(input.projectPath);
-    return {
-        contractId: input.contract?.id || null,
-        integration: input.integration,
-        dependencyId: input.dependencyId,
-        projectPath: input.projectPath,
-        installDependencies: input.installDependencies,
-        verifyPackageIds: input.verifyPackageIds,
-        resolutionBases: bases
-    };
-}
-async function ensureOptionalPackageResolved(input) {
-    const contract = getVerificationContract(input);
-    const missing = getContractVerificationFailuresFromKnownLocations(contract, input.projectPath);
-    const resolved = resolveFromKnownLocations(input.dependencyId, input.projectPath);
-    if (resolved && 0 === missing.length) return resolved;
-    const diagnostics = buildDiagnostics({
-        integration: input.integration,
-        dependencyId: input.dependencyId,
-        projectPath: input.projectPath,
-        contract,
-        installDependencies: contract.installPackages,
-        verifyPackageIds: contract.installPackages
-    });
-    const headline = `${input.dependencyId} could not be resolved.` + (missing.length > 0 ? ` Missing or invalid packages: ${missing.join(', ')}.` : '');
-    throw new Error(formatResolverError({
-        integration: input.integration,
-        dependencyId: input.dependencyId,
-        headline,
-        installSpecs: missing.length > 0 ? missing : contract.installPackages,
-        projectPath: input.projectPath,
-        diagnostics: {
-            ...diagnostics,
-            missing
-        }
-    }));
-}
-function resolveOptionalPackageWithoutInstall(input) {
-    const contract = getVerificationContract(input);
-    const resolved = resolveFromKnownLocations(input.dependencyId, input.projectPath);
-    const missingPeerDeps = getContractVerificationFailuresFromKnownLocations(contract, input.projectPath);
-    if (resolved && 0 === missingPeerDeps.length) return resolved;
-    const diagnostics = buildDiagnostics({
-        integration: input.integration,
-        dependencyId: input.dependencyId,
-        projectPath: input.projectPath,
-        contract,
-        installDependencies: contract.installPackages,
-        verifyPackageIds: contract.installPackages
-    });
-    throw new Error(formatResolverError({
-        integration: input.integration,
-        dependencyId: input.dependencyId,
-        headline: `${input.dependencyId} could not be resolved from the project or extension-develop.`,
-        installSpecs: missingPeerDeps.length > 0 ? missingPeerDeps : contract.installPackages,
-        projectPath: input.projectPath,
-        diagnostics: {
-            ...diagnostics,
-            missingPeerDeps,
-            expectation: 'Run optional dependency preflight or reinstall extension-develop.'
-        }
-    }));
-}
-async function ensureOptionalModuleLoaded(input) {
-    const resolvedPath = await ensureOptionalPackageResolved(input);
-    const candidateBases = getResolutionBases(input.projectPath);
-    let loaded;
-    let didLoad = false;
-    let lastLoadError;
-    for (const basePath of candidateBases){
-        const req = createRequire(optional_deps_resolver_packageJsonPath(basePath));
-        const candidateModuleIds = [
-            input.dependencyId,
-            resolvedPath
-        ];
-        for (const candidateModuleId of candidateModuleIds)try {
-            loaded = req(candidateModuleId);
-            didLoad = true;
-            break;
-        } catch (error) {
-            lastLoadError = error;
-        }
-        if (didLoad) break;
-    }
-    if (!didLoad) try {
-        loaded = require(resolvedPath);
-        didLoad = true;
-    } catch (directRequireError) {
-        lastLoadError = directRequireError;
-    }
-    if (!didLoad) {
-        const diagnostics = {
-            ...buildDiagnostics({
-                integration: input.integration,
-                dependencyId: input.dependencyId,
-                projectPath: input.projectPath,
-                installDependencies: input.installDependencies || [
-                    input.dependencyId
-                ],
-                verifyPackageIds: input.verifyPackageIds || input.installDependencies || [
-                    input.dependencyId
-                ]
-            }),
-            resolvedPath,
-            loadError: lastLoadError instanceof Error ? lastLoadError.message : String(lastLoadError)
-        };
-        throw new Error(formatResolverError({
-            integration: input.integration,
-            dependencyId: input.dependencyId,
-            headline: `${input.dependencyId} could not be loaded after it resolved.`,
-            installSpecs: input.installDependencies || [
-                input.dependencyId
-            ],
-            projectPath: input.projectPath,
-            diagnostics
-        }));
-    }
-    return input.moduleAdapter ? input.moduleAdapter(loaded) : loaded;
-}
-function loadOptionalModuleWithoutInstall(input) {
-    const resolvedPath = resolveOptionalPackageWithoutInstall(input);
-    const candidateBases = getResolutionBases(input.projectPath);
-    let loaded;
-    let didLoad = false;
-    let lastLoadError;
-    for (const basePath of candidateBases){
-        const req = createRequire(optional_deps_resolver_packageJsonPath(basePath));
-        const candidateModuleIds = [
-            input.dependencyId,
-            resolvedPath
-        ];
-        for (const candidateModuleId of candidateModuleIds)try {
-            loaded = req(candidateModuleId);
-            didLoad = true;
-            break;
-        } catch (error) {
-            lastLoadError = error;
-        }
-        if (didLoad) break;
-    }
-    if (!didLoad) try {
-        loaded = require(resolvedPath);
-        didLoad = true;
-    } catch (directRequireError) {
-        lastLoadError = directRequireError;
-    }
-    if (!didLoad) throw new Error(formatResolverError({
-        integration: input.integration,
-        dependencyId: input.dependencyId,
-        headline: `${input.dependencyId} could not be loaded after resolving.`,
-        installSpecs: input.installDependencies || [
-            input.dependencyId
-        ],
-        projectPath: input.projectPath,
-        diagnostics: {
-            resolvedPath,
-            loadError: lastLoadError instanceof Error ? lastLoadError.message : String(lastLoadError)
-        }
-    }));
-    return input.moduleAdapter ? input.moduleAdapter(loaded) : loaded;
-}
-async function ensureOptionalContractPackageResolved(input) {
-    const contract = getOptionalDependencyContract(input.contractId);
-    return ensureOptionalPackageResolved({
-        integration: contract.integration,
-        projectPath: input.projectPath,
-        dependencyId: input.dependencyId,
-        contract
-    });
-}
-async function ensureOptionalContractModuleLoaded(input) {
-    const contract = getOptionalDependencyContract(input.contractId);
-    return ensureOptionalModuleLoaded({
-        integration: contract.integration,
-        projectPath: input.projectPath,
-        dependencyId: input.dependencyId,
-        contract,
-        moduleAdapter: input.moduleAdapter
-    });
-}
-function resolveOptionalContractPackageWithoutInstall(input) {
-    const contract = getOptionalDependencyContract(input.contractId);
-    return resolveOptionalPackageWithoutInstall({
-        integration: contract.integration,
-        projectPath: input.projectPath,
-        dependencyId: input.dependencyId,
-        contract
-    });
-}
-function loadOptionalContractModuleWithoutInstall(input) {
-    const contract = getOptionalDependencyContract(input.contractId);
-    return loadOptionalModuleWithoutInstall({
-        integration: contract.integration,
-        projectPath: input.projectPath,
-        dependencyId: input.dependencyId,
-        contract,
-        moduleAdapter: input.moduleAdapter
-    });
-}
 let userMessageDelivered = false;
 function isUsingLess(projectPath) {
     if (hasDependency(projectPath, 'less')) {