@octanejs/cli 0.0.12 → 0.1.0

package/README.md

@@ -88,6 +88,21 @@ A file that will not parse is reported as an error and does not stop the rest of
 the run. Exit code is `3` when anything error-severity was found, or when
 `--strict` and there were warnings.
 
+Modules that `compiler.strong` in `octane.config.ts` reaches are analyzed in
+Strong mode, as the build compiles them.
+
+### Strong coverage
+
+`octane analyze --strong-baseline init` records every module that compiles
+without Strong mode in `octane-strong-baseline.json`. While that file exists,
+every run fails on a module that is neither Strong nor listed
+(`OCTANE_STRONG_COVERAGE_REGRESSION`), such as one whose `"use strong"` was
+deleted, and on a listed name that is now Strong or gone
+(`OCTANE_STRONG_COVERAGE_STALE`). `--strong-baseline update` removes stale
+names and never adds one, so a new exception is always a reviewed edit to the
+file. See
+[Keeping modules Strong](https://github.com/octanejs/octane/blob/main/docs/strong-compiler-checks.md#keeping-modules-strong).
+
 ## For agents and CI
 
 Every command is fully drivable by flags and emits a single JSON document under

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@octanejs/cli",
-  "version": "0.0.12",
+  "version": "0.1.0",
   "type": "module",
   "engines": {
     "node": ">=22.22.2"

package/src/commands/{analyze.js → analyze/index.js}

@@ -2,9 +2,20 @@ import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { defineCommand } from '../kernel/command.js';
-import { CliError, EXIT } from '../kernel/errors.js';
-import { SYMBOLS } from '../kernel/ui.js';
+import { defineCommand } from '../../kernel/command.js';
+import { CliError, EXIT, usageError } from '../../kernel/errors.js';
+import { SOURCE_FILE_LIMIT } from '../../kernel/project.js';
+import { SYMBOLS } from '../../kernel/ui.js';
+import {
+	BASELINE_FILE,
+	STALE,
+	compareCoverage,
+	isOctaneModule,
+	loadStrongPolicy,
+	projectPath,
+	readBaseline,
+	writeBaseline,
+} from './strong-coverage.js';
 
 /**
  * @typedef {Object} Finding
@@ -74,6 +85,13 @@ function describeSuggestions(suggestions) {
  */
 const TRAILING_LOCATION = /\s*\(([^()\s]+):(\d+):(\d+)\)\s*$/;
 
+/**
+ * A compiler error that carries its own code, e.g. a Strong rule:
+ * `/abs/App.tsrx:4:21: [OCTANE_STRONG_EFFECT_STATE_UPDATE] Strong mode …`.
+ * The position is already in the finding's columns.
+ */
+const COMPILER_CODE = /^(?:[^\n]*?:\d+:\d+: )?\[(OCTANE_[A-Z0-9_]+)\] /;
+
 /**
  * Normalise a thrown compile failure into a finding.
  *
@@ -88,7 +106,12 @@ const TRAILING_LOCATION = /\s*\(([^()\s]+):(\d+):(\d+)\)\s*$/;
  * @returns {Finding}
  */
 function thrownFailure(error, file, code) {
-	const message = error instanceof Error ? error.message : String(error);
+	const thrown = error instanceof Error ? error.message : String(error);
+	// A coded compiler error names its rule; reporting it as a parse failure
+	// would hide the code that `--code` filters on and the docs index.
+	const coded = COMPILER_CODE.exec(thrown);
+	const message = coded ? thrown.slice(coded[0].length) : thrown;
+	code ??= coded?.[1];
 	const loc = /** @type {any} */ (error)?.loc;
 	if (loc) {
 		return {
@@ -136,26 +159,75 @@ export default defineCommand({
 			description: 'Only report this diagnostic code. Repeatable.',
 		},
 		strict: { type: 'boolean', description: 'Fail the run on warnings, not just errors.' },
+		'strong-baseline': {
+			type: 'string',
+			choices: ['init', 'update'],
+			placeholder: '<init|update>',
+			description:
+				`Write ${BASELINE_FILE}, the modules allowed to compile without Strong mode.\n` +
+				'init records every such module once; update only removes names that are no\n' +
+				'longer exceptions. While the file exists, every run fails on a module that\n' +
+				'is neither Strong nor listed, and on a listed name that is out of date.',
+		},
 	},
 
 	async run(ctx, input) {
 		const project = ctx.project();
 		const compile = await loadCompiler(project.root);
 
+		// Coverage is a property of the whole project: an explicit file list can
+		// show that one of its files regressed, but not that a recorded exception
+		// went stale, and it must never write the baseline.
+		const whole = input.positionals.length === 0;
+		const write = /** @type {'init' | 'update' | undefined} */ (input.flags['strong-baseline']);
+		if (write !== undefined && !whole) {
+			throw usageError('--strong-baseline measures the whole project; drop the file arguments.');
+		}
+		let baseline = readBaseline(project.root);
+		if (write === 'init' && baseline !== null) {
+			throw usageError(
+				`${BASELINE_FILE} already exists.`,
+				'`--strong-baseline update` removes names that are no longer exceptions; it never adds one.',
+			);
+		}
+		if (write === 'update' && baseline === null) {
+			throw usageError(
+				`${BASELINE_FILE} does not exist.`,
+				'Record one with `--strong-baseline init`.',
+			);
+		}
+		const measureCoverage = baseline !== null || write !== undefined;
+		const { policy, reason } = await loadStrongPolicy(project, { required: measureCoverage });
+
 		const targets =
 			input.positionals.length > 0
 				? input.positionals.map((file) => path.resolve(ctx.cwd, file))
 				: project.tsrxFiles;
 
-		if (targets.length === 0) {
+		if (targets.length === 0 && !measureCoverage) {
 			ctx.ui.intro('octane analyze');
 			ctx.ui.outro('No .tsrx files found.');
 			return { json: { ok: true, analyzed: 0, findings: [] } };
 		}
 
 		ctx.ui.intro('octane analyze');
+		if (reason !== undefined) ctx.ui.log(ctx.ui.colors.yellow(`${SYMBOLS.warn} ${reason}`));
 		const spinner = ctx.ui.spinner(`Compiling ${targets.length} file(s)`);
 
+		/** @type {Map<string, string>} */
+		const sources = new Map();
+		/** @type {Map<string, import('./strong-coverage.js').StrongStatus>} */
+		const statuses = new Map();
+		// One parse per module answers both the compile options and coverage.
+		/** @param {string} absolute @param {string} source */
+		const statusOf = (absolute, source) => {
+			let status = statuses.get(absolute);
+			if (status === undefined && policy) {
+				status = policy.status(source, absolute);
+				statuses.set(absolute, status);
+			}
+			return status;
+		};
 		/** @type {Finding[]} */
 		const findings = [];
 		for (const absolute of targets) {
@@ -168,9 +240,18 @@ export default defineCommand({
 				findings.push(thrownFailure(error, file, 'OCTANE_READ_ERROR'));
 				continue;
 			}
+			sources.set(absolute, source);
 
+			// Analyze under the policy the build applies: octane.config's
+			// compiler.strong reaches this module without a directive of its own.
+			let options = {};
+			try {
+				if (statusOf(absolute, source)?.config) options = { strong: true };
+			} catch {
+				// Unparseable; the compile below reports it in its own terms.
+			}
 			try {
-				for (const diagnostic of compile(source, absolute, {}).diagnostics ?? []) {
+				for (const diagnostic of compile(source, absolute, options).diagnostics ?? []) {
 					findings.push({
 						file,
 						line: diagnostic.start?.line ?? 1,
@@ -196,6 +277,99 @@ export default defineCommand({
 		}
 		spinner.stop(`Compiled ${targets.length} file(s)`);
 
+		/** @type {Record<string, unknown> | undefined} */
+		let strongCoverage;
+		if (measureCoverage && policy !== null) {
+			if (whole && project.sourceFiles.length >= SOURCE_FILE_LIMIT) {
+				throw new CliError(
+					`The project has more than ${SOURCE_FILE_LIMIT} source files, so Strong coverage cannot be measured completely.`,
+				);
+			}
+			const jsxImportSource = project.tsconfig?.config?.compilerOptions?.jsxImportSource;
+			/** @type {import('./strong-coverage.js').CoverageModule[]} */
+			const modules = [];
+			/** @type {Set<string>} */
+			const unmeasured = new Set();
+			for (const absolute of whole ? project.sourceFiles : targets) {
+				const file = projectPath(project.root, absolute);
+				if (file.startsWith('../') || path.isAbsolute(file)) continue;
+				let source = sources.get(absolute);
+				if (source === undefined) {
+					try {
+						source = readFileSync(absolute, 'utf8');
+					} catch {
+						unmeasured.add(file);
+						continue;
+					}
+				}
+				if (!isOctaneModule(absolute, source, jsxImportSource, policy)) continue;
+				try {
+					const status = /** @type {import('./strong-coverage.js').StrongStatus} */ (
+						statusOf(absolute, source)
+					);
+					modules.push({ file, absolute, status });
+				} catch {
+					// A module that does not parse fails its build and, as a target,
+					// this report. It is neither a regression nor proof of staleness.
+					unmeasured.add(file);
+				}
+			}
+
+			if (write === 'init') {
+				const exceptions = modules.filter((module) => !module.status.strong);
+				if (!ctx.dryRun)
+					writeBaseline(
+						project.root,
+						exceptions.map((module) => module.file),
+					);
+				baseline = {
+					path: path.join(project.root, BASELINE_FILE),
+					text: '',
+					exceptions: exceptions.map((module) => module.file),
+				};
+			}
+			const current = /** @type {import('./strong-coverage.js').Baseline} */ (baseline);
+			const comparison = compareCoverage({
+				modules,
+				baseline: current,
+				policy,
+				complete: whole,
+				unmeasured,
+				display: (absolute) => displayPath(project.root, ctx.cwd, absolute),
+			});
+			let exceptions = current.exceptions;
+			let coverageFindings = comparison.findings;
+			if (write === 'update') {
+				const stale = new Set(comparison.stale);
+				exceptions = exceptions.filter((entry) => !stale.has(entry));
+				if (!ctx.dryRun) {
+					writeBaseline(project.root, exceptions);
+					coverageFindings = coverageFindings.filter((finding) => finding.code !== STALE);
+				}
+			}
+			findings.push(...coverageFindings);
+
+			const strong = modules.filter((module) => module.status.strong).length;
+			ctx.ui.log(
+				`Strong coverage: ${strong} of ${modules.length} module(s), ${exceptions.length} recorded exception(s)`,
+			);
+			if (write !== undefined) {
+				const changed =
+					write === 'init'
+						? `${ctx.dryRun ? 'Would record' : 'Recorded'} ${exceptions.length} exception(s)`
+						: `${ctx.dryRun ? 'Would remove' : 'Removed'} ${comparison.stale.length} name(s)`;
+				ctx.ui.log(`${changed} in ${BASELINE_FILE}`);
+			}
+			strongCoverage = {
+				baseline: BASELINE_FILE,
+				modules: modules.length,
+				strong,
+				exceptions: exceptions.length,
+				regressions: comparison.regressions,
+				stale: comparison.stale,
+			};
+		}
+
 		const selected = input.flags.code?.length
 			? findings.filter((finding) => input.flags.code.includes(finding.code))
 			: findings;
@@ -214,6 +388,7 @@ export default defineCommand({
 				analyzed: targets.length,
 				summary: { errors, warnings, hints },
 				findings: selected,
+				...(strongCoverage === undefined ? null : { strongCoverage }),
 			},
 		};
 	},
@@ -237,7 +412,7 @@ function displayPath(root, cwd, absolute) {
 }
 
 /**
- * @param {import('../kernel/context.js').Ctx} ctx
+ * @param {import('../../kernel/context.js').Ctx} ctx
  * @param {Finding[]} findings
  * @param {number} analyzed
  */

package/src/commands/analyze/strong-coverage.js

@@ -0,0 +1,304 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { CliError } from '../../kernel/errors.js';
+import { resolveConfigLoader } from '../../kernel/octane-config.js';
+
+/**
+ * The checked-in list of modules allowed to compile without Strong mode.
+ *
+ * Strong is opt-in per module or per application, so the cheapest way around
+ * a Strong diagnostic is to stop being Strong: delete `"use strong"`, turn
+ * `compiler.strong` off, or move the code into another package. Each of those
+ * is a one-line change that is easy to miss in review. With this file in the
+ * project, every module Octane compiles has to be Strong or be named here, and
+ * `octane analyze` only ever removes names. A new exception therefore shows up
+ * as an edit to this one file, which a team can route to an owner.
+ */
+export const BASELINE_FILE = 'octane-strong-baseline.json';
+
+export const REGRESSION = 'OCTANE_STRONG_COVERAGE_REGRESSION';
+export const STALE = 'OCTANE_STRONG_COVERAGE_STALE';
+
+/**
+ * @typedef {{ strong: boolean, directive: boolean, config: boolean }} StrongStatus
+ *
+ * @typedef {Object} StrongPolicy
+ * @property {boolean} configured `compiler.strong` from octane.config
+ * @property {(source: string, absolute: string) => StrongStatus} status
+ * @property {(source: string) => string | null} jsxPragma the leading
+ *   `@jsxImportSource` module, read by the compiler's own scanner
+ *
+ * @typedef {Object} CoverageModule
+ * @property {string} file project-relative, `/`-separated
+ * @property {string} absolute
+ * @property {StrongStatus} status
+ *
+ * @typedef {Object} Baseline
+ * @property {string} path
+ * @property {string} text
+ * @property {string[]} exceptions
+ */
+
+/**
+ * The project's Strong policy, decided by the project's own compiler.
+ *
+ * `compiler.strong` comes from evaluating octane.config, and the per-module
+ * answer comes from the installed bundler compiler's `strongModuleStatus`, the
+ * same decision its `transform` makes. Nothing here re-derives the directive
+ * prologue or the package-boundary rule.
+ *
+ * `required` is set when the answer is about to gate a run (a baseline exists
+ * or one is being written). A policy that cannot be determined then fails the
+ * run. Otherwise the policy only decides whether `compiler.strong` reaches a
+ * module, so a project without it needs nothing more (`{ policy: null }`), and
+ * one whose setting cannot be applied gets the `reason` to show beside the
+ * diagnostics it could still produce.
+ *
+ * @param {import('../../kernel/project.js').Project} project
+ * @param {{ required: boolean }} options
+ * @returns {Promise<{ policy: StrongPolicy | null, reason?: string }>}
+ */
+export async function loadStrongPolicy(project, { required }) {
+	/** @param {string} reason */
+	const unavailable = (reason) => {
+		if (required) throw new CliError(reason);
+		return { policy: null, reason };
+	};
+
+	let configured = false;
+	if (project.octaneConfigPath !== null) {
+		const file = path.basename(project.octaneConfigPath);
+		const load = await resolveConfigLoader(project.root);
+		if (!load) {
+			return unavailable(
+				`${file} could not be evaluated because @octanejs/app-core is not installed, so its compiler.strong setting is unknown.`,
+			);
+		}
+		try {
+			configured = (await load(project.root)).compiler?.strong === true;
+		} catch (error) {
+			return unavailable(
+				`${file} failed to load, so its compiler.strong setting is unknown: ${
+					error instanceof Error ? error.message : String(error)
+				}`,
+			);
+		}
+	}
+
+	if (!required && !configured) return { policy: null };
+
+	let bundler;
+	try {
+		const require = createRequire(path.join(project.root, 'noop.js'));
+		bundler = await import(pathToFileURL(require.resolve('octane/compiler/bundler')).href);
+	} catch {
+		return unavailable('Could not resolve `octane/compiler/bundler` from this project.');
+	}
+	const compiler = bundler.createOctaneCompiler?.({ root: project.root, strong: configured });
+	if (
+		typeof compiler?.strongModuleStatus !== 'function' ||
+		typeof bundler.findLeadingJsxImportSourcePragma !== 'function'
+	) {
+		return unavailable(
+			'The installed octane cannot report which modules compile under Strong mode. Update octane.',
+		);
+	}
+
+	return {
+		policy: {
+			configured,
+			status: (source, absolute) => compiler.strongModuleStatus(source, absolute),
+			jsxPragma: bundler.findLeadingJsxImportSourcePragma,
+		},
+	};
+}
+
+/**
+ * An import of octane or one of its subpaths, capturing its clause. The clause
+ * may span lines but never reaches into the next `import`, so a semicolon-free
+ * module cannot borrow a later import's specifier.
+ */
+const OCTANE_IMPORT =
+	/^\s*import\s+((?:(?!\bimport\b)[^;])*?)\s*\bfrom\s*['"]octane(?:\/[^'"]*)?['"]/gm;
+
+/**
+ * Does the module import a runtime binding from octane? TypeScript erases an
+ * `import type` clause and a named clause whose every specifier is
+ * `type`-marked, so neither leaves anything for the compiler to slot. A
+ * default or namespace binding, or any unmarked specifier, survives. Comments
+ * in the clause are not specifiers, so they are dropped before it is read.
+ *
+ * @param {string} source
+ */
+function importsOctaneAtRuntime(source) {
+	for (const [, authored] of source.matchAll(OCTANE_IMPORT)) {
+		const clause = authored.replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, ' ').trim();
+		if (/^type\b/.test(clause)) continue;
+		const named = /^\{([\s\S]*)\}$/.exec(clause);
+		if (named === null) return true;
+		const specifiers = named[1]
+			.split(',')
+			.map((specifier) => specifier.trim())
+			.filter(Boolean);
+		if (!specifiers.every((specifier) => /^type\s/.test(specifier))) return true;
+	}
+	return false;
+}
+
+/**
+ * @param {string | undefined} source a JSX import source
+ */
+function isOctaneJsxSource(source) {
+	return source === 'octane' || source === 'octane/strong' || !!source?.startsWith('@octanejs/');
+}
+
+/**
+ * Is this a module Octane compiles, and so one Strong can reach?
+ *
+ * `.tsrx` always is. A `.tsx` module is unless its own leading pragma, or the
+ * tsconfig `jsxImportSource`, hands its JSX to another library, as a
+ * React-hosted project does. A plain `.ts`/`.js` module is when it imports
+ * octane at runtime, which is when the compiler slots its hooks. Declaration
+ * files and other extensions never are.
+ *
+ * @param {string} absolute
+ * @param {string} source
+ * @param {string | undefined} jsxImportSource from tsconfig
+ * @param {StrongPolicy} policy
+ */
+export function isOctaneModule(absolute, source, jsxImportSource, policy) {
+	if (absolute.endsWith('.d.ts')) return false;
+	const extension = path.extname(absolute);
+	if (extension === '.tsrx') return true;
+	if (extension === '.tsx') {
+		const pragma = policy.jsxPragma(source);
+		if (pragma !== null) return isOctaneJsxSource(pragma);
+		return jsxImportSource === undefined || isOctaneJsxSource(jsxImportSource);
+	}
+	if (extension === '.ts' || extension === '.js') return importsOctaneAtRuntime(source);
+	return false;
+}
+
+/**
+ * @param {string} root
+ * @param {string} absolute
+ */
+export function projectPath(root, absolute) {
+	return path.relative(root, absolute).split(path.sep).join('/');
+}
+
+/**
+ * @param {string} root
+ * @returns {Baseline | null}
+ */
+export function readBaseline(root) {
+	const file = path.join(root, BASELINE_FILE);
+	if (!existsSync(file)) return null;
+	const text = readFileSync(file, 'utf8');
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch (error) {
+		throw new CliError(
+			`${BASELINE_FILE} is not valid JSON: ${error instanceof Error ? error.message : error}`,
+		);
+	}
+	if (
+		parsed?.version !== 1 ||
+		!Array.isArray(parsed.exceptions) ||
+		parsed.exceptions.some((/** @type {unknown} */ entry) => typeof entry !== 'string')
+	) {
+		throw new CliError(
+			`${BASELINE_FILE} must be { "version": 1, "exceptions": [<project-relative paths>] }.`,
+		);
+	}
+	return { path: file, text, exceptions: parsed.exceptions };
+}
+
+/**
+ * Sorted and deduplicated, so the file only changes when its contents do.
+ *
+ * @param {string} root
+ * @param {Iterable<string>} exceptions
+ */
+export function writeBaseline(root, exceptions) {
+	const body = { version: 1, exceptions: [...new Set(exceptions)].sort() };
+	writeFileSync(path.join(root, BASELINE_FILE), `${JSON.stringify(body, null, '\t')}\n`);
+}
+
+/**
+ * Compare the measured modules with the recorded exceptions.
+ *
+ * A non-Strong module that is not listed is a regression: something new, or
+ * something that stopped being Strong. A listed module that is Strong, gone, or
+ * no longer compiled by Octane is stale, and is an error too, because a stale
+ * name is a pre-approved slot for the next regression. Staleness is only known
+ * when every module was measured.
+ *
+ * @param {{
+ *   modules: CoverageModule[],
+ *   baseline: Baseline,
+ *   policy: StrongPolicy,
+ *   complete: boolean,
+ *   unmeasured: ReadonlySet<string>,
+ *   display: (absolute: string) => string,
+ * }} input
+ */
+export function compareCoverage({ modules, baseline, policy, complete, unmeasured, display }) {
+	const listed = new Set(baseline.exceptions);
+	const measured = new Map(modules.map((module) => [module.file, module]));
+	const baselineDisplay = display(baseline.path);
+
+	/** @type {import('./index.js').Finding[]} */
+	const findings = [];
+	/** @type {string[]} */
+	const regressions = [];
+	for (const module of modules) {
+		if (module.status.strong || listed.has(module.file)) continue;
+		regressions.push(module.file);
+		const fix =
+			policy.configured && !module.status.config
+				? 'compiler.strong in octane.config does not reach modules of another package, so add "use strong" before its imports'
+				: 'Add "use strong" before its imports, or enable compiler.strong in octane.config,';
+		findings.push({
+			file: display(module.absolute),
+			line: 1,
+			column: 1,
+			severity: 'error',
+			code: REGRESSION,
+			message: `This module compiles without Strong mode and is not a recorded exception. ${fix} and fix what Strong then reports. A new exception is a reviewed edit to ${BASELINE_FILE}; octane analyze never adds one.`,
+			suggestions: [],
+		});
+	}
+
+	/** @type {string[]} */
+	const stale = [];
+	if (complete) {
+		const lines = baseline.text.split('\n');
+		for (const entry of baseline.exceptions) {
+			const module = measured.get(entry);
+			if (unmeasured.has(entry) || (module !== undefined && !module.status.strong)) continue;
+			stale.push(entry);
+			const why =
+				module !== undefined
+					? 'now compiles with Strong mode'
+					: existsSync(path.join(path.dirname(baseline.path), entry))
+						? 'is not a module Octane compiles'
+						: 'no longer exists';
+			const index = lines.findIndex((line) => line.includes(JSON.stringify(entry)));
+			findings.push({
+				file: baselineDisplay,
+				line: index === -1 ? 1 : index + 1,
+				column: 1,
+				severity: 'error',
+				code: STALE,
+				message: `${entry} ${why}, so it is no longer an exception. Run \`octane analyze --strong-baseline update\` to remove it.`,
+				suggestions: [],
+			});
+		}
+	}
+
+	return { findings, regressions, stale };
+}

package/src/commands/doctor/checks/config.js

@@ -1,7 +1,6 @@
 import { existsSync } from 'node:fs';
-import { createRequire } from 'node:module';
 import path from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { resolveConfigLoader } from '../../../kernel/octane-config.js';
 import { readInstalled } from '../../../kernel/project.js';
 import { fail, pass, skip, warn } from '../check.js';
 
@@ -10,45 +9,6 @@ const ADAPTERS = {
 	cloudflare: '@octanejs/adapter-cloudflare',
 };
 
-/**
- * Load the project's own config loader rather than shipping a second one.
- *
- * `@octanejs/app-core` is usually a transitive dependency of the bundler
- * plugin, not a direct one, so a plain resolve from the project root misses it.
- * Falling back to a resolve rooted at the plugin reproduces exactly the lookup
- * the plugin itself performs.
- *
- * @param {string} root
- * @returns {Promise<((root: string) => Promise<any>) | null>}
- */
-async function resolveConfigLoader(root) {
-	const fromProject = createRequire(path.join(root, 'noop.js'));
-	const specifier = '@octanejs/app-core/config-loader';
-
-	/** @type {string | null} */
-	let entry = null;
-	try {
-		entry = fromProject.resolve(specifier);
-	} catch {
-		for (const plugin of [
-			'@octanejs/vite-plugin',
-			'@octanejs/rspack-plugin',
-			'@octanejs/rsbuild-plugin',
-		]) {
-			try {
-				entry = createRequire(fromProject.resolve(plugin)).resolve(specifier);
-				break;
-			} catch {
-				// Try the next plugin.
-			}
-		}
-	}
-
-	if (!entry) return null;
-	const module = await import(pathToFileURL(entry).href);
-	return module.loadOctaneConfig ?? null;
-}
-
 /**
  * Loading the config means running esbuild over `octane.config.ts`. All three
  * config checks need the same result, so it is computed once instead of three