@tsrx/oxc 0.0.0-trusted-publishing-bootstrap → 0.8.0

package/dist/provider-resolve.d.ts

@@ -0,0 +1,160 @@
+export type OxcProviderCapabilityName = "parse" | "lint" | "format" | "lsp";
+
+export type OxcProviderDiagnosticCode =
+  | "ancestor-provider"
+  | "duplicate-id"
+  | "extension-conflict"
+  | "invalid-capability"
+  | "invalid-provider"
+  | "reserved-extension"
+  | "unreadable-manifest"
+  | "unresolved-capability"
+  | "unsupported-protocol";
+
+export interface OxcProviderDiagnostic {
+  readonly severity: "error" | "warning";
+  readonly code: OxcProviderDiagnosticCode;
+  readonly message: string;
+  readonly packages?: readonly string[];
+  readonly extension?: string;
+  readonly capability?: OxcProviderCapabilityName;
+  readonly protocol?: number;
+  readonly id?: string;
+  readonly manifest?: string;
+  readonly root?: string;
+}
+
+export interface OxcProviderBinCapability {
+  readonly kind: "bin";
+  readonly bin: string;
+  readonly path: string;
+}
+
+export interface OxcProviderModuleCapability {
+  readonly kind: "module";
+  readonly subpath: string;
+  readonly specifier: string;
+  readonly path: string | null;
+}
+
+export type OxcProviderCapability = OxcProviderBinCapability | OxcProviderModuleCapability;
+
+export type OxcProviderCapabilities = {
+  readonly [key in OxcProviderCapabilityName]?: OxcProviderCapability;
+};
+
+export interface OxcProviderLanguage {
+  readonly id: string;
+  readonly extensions: readonly string[];
+  readonly capabilities: OxcProviderCapabilities;
+}
+
+export interface OxcProvider {
+  readonly name: string;
+  readonly version: string | null;
+  readonly root: string;
+  readonly manifest: string;
+  readonly protocol: number;
+  readonly id: string;
+  readonly languages: readonly OxcProviderLanguage[];
+}
+
+export interface OxcProviderExtension {
+  readonly extension: string;
+  readonly package: string;
+  readonly providerId: string;
+  readonly providerRoot: string;
+  readonly language: string;
+  readonly capabilities: OxcProviderCapabilities;
+}
+
+export interface OxcProviderIndex {
+  readonly root: string;
+  readonly providers: readonly OxcProvider[];
+  readonly extensions: { readonly [extension: string]: OxcProviderExtension };
+  readonly diagnostics: readonly OxcProviderDiagnostic[];
+}
+
+/**
+ * Issuer-aware module resolution. A Plug'n'Play host passes its PnP API's
+ * `resolveRequest`, which already has this exact `(request, issuer)` shape.
+ */
+export type OxcProviderResolve = (request: string, issuer: string) => string;
+
+/**
+ * Manifest reader. It must read through the same layer `resolve` answers from.
+ *
+ * Under Plug'n'Play there is no `node_modules`: packages stay zipped in
+ * `.yarn/cache` and `.pnp.cjs` answers with a path *into* the archive, which an
+ * ordinary `fs.readFile` cannot open (it fails with `ENOTDIR`). A host that
+ * injects the PnP resolver but keeps reading with an ordinary `fs` resolves
+ * every manifest and reads none of them.
+ */
+export type OxcProviderReadFile = (
+  path: string,
+  encoding: "utf8",
+) => string | Promise<string | Uint8Array>;
+
+/**
+ * Host obligation: `resolve` and `readFile` travel together. Injecting one
+ * without the other is a host fault, not a protocol option.
+ *
+ * A Plug'n'Play host must supply both the PnP `resolveRequest` **and** a reader
+ * backed by the PnP filesystem layer, which in practice means running under the
+ * PnP runtime (`--require .pnp.cjs`, or a `yarn node` launcher) so `fs` is
+ * patched to see inside the zip. An injected resolver alone is not enough.
+ *
+ * A host that gets this wrong is told so. A dependency manifest that resolves
+ * and then cannot be read or parsed produces an `unreadable-manifest` warning
+ * naming the package and the manifest path, so a Plug'n'Play host with an
+ * unpatched reader sees one warning per direct dependency instead of an empty
+ * index and silence. A dependency that does not resolve at all stays quiet,
+ * because that only means it is not installed.
+ */
+export interface OxcProviderDiscoveryOptions {
+  readonly root?: string;
+  readonly resolve?: OxcProviderResolve;
+  readonly readFile?: OxcProviderReadFile;
+  readonly protocols?: readonly number[];
+  readonly throwOnError?: boolean;
+  readonly inspectAncestors?: boolean;
+}
+
+export type OxcResolvedCapability = OxcProviderCapability & {
+  readonly package: string;
+  readonly providerId: string;
+  readonly providerRoot: string;
+  readonly language: string;
+  readonly extension: string;
+  readonly capability: OxcProviderCapabilityName;
+};
+
+export declare const PROTOCOL_VERSION: 1;
+export declare const SUPPORTED_PROTOCOLS: readonly number[];
+export declare const CAPABILITY_NAMES: readonly OxcProviderCapabilityName[];
+export declare const DEPENDENCY_FIELDS: readonly string[];
+export declare const RESERVED_EXTENSIONS: readonly string[];
+
+export declare class ProviderProtocolError extends Error {
+  readonly diagnostics: readonly OxcProviderDiagnostic[];
+  constructor(diagnostics: readonly OxcProviderDiagnostic[]);
+}
+
+export declare function dependencyNames(manifest: unknown): string[];
+export declare function providerDeclaration(manifest: unknown): Record<string, unknown> | null;
+export declare function extensionOf(filePath: string): string | null;
+export declare function isReservedExtension(extension: string): boolean;
+export declare function findProjectRoot(
+  start?: string,
+  options?: { readonly readFile?: OxcProviderReadFile },
+): Promise<string>;
+export declare function discoverProviders(
+  options?: OxcProviderDiscoveryOptions,
+): Promise<OxcProviderIndex>;
+export declare function providerExtensions(index: OxcProviderIndex): string[];
+export declare function hasProviderErrors(index: OxcProviderIndex): boolean;
+export declare function resolveCapability(
+  index: OxcProviderIndex,
+  filePath: string,
+  capability: OxcProviderCapabilityName,
+): OxcResolvedCapability | null;

package/dist/provider-resolve.js

@@ -0,0 +1,471 @@
+import { createRequire } from "node:module";
+import { readFile } from "node:fs/promises";
+import { dirname, join, parse, relative, resolve, sep } from "node:path";
+//#region src/provider-resolve.ts
+/**
+* Reference implementation of the static `oxc.provider` discovery protocol.
+*
+* A provider declares one static top-level `oxc.provider` block in its own
+* package.json. A host reads the project root manifest, takes the union of the
+* direct dependency fields, resolves `<name>/package.json` for each, parses the
+* JSON, and builds an extension index. Nothing in this file imports, requires,
+* or spawns a dependency: module resolution and `JSON.parse` are the only
+* operations performed against a candidate package.
+*
+* The module deliberately contains no knowledge of any individual provider, so
+* it can be vendored by an unrelated host unchanged.
+*/
+const PROTOCOL_VERSION = 1;
+const SUPPORTED_PROTOCOLS = Object.freeze([1]);
+const CAPABILITY_NAMES = Object.freeze([
+	"parse",
+	"lint",
+	"format",
+	"lsp"
+]);
+const DEPENDENCY_FIELDS = Object.freeze([
+	"dependencies",
+	"devDependencies",
+	"optionalDependencies"
+]);
+/**
+* Extensions the core toolchain owns. A provider claiming one is a hard error,
+* which is what structurally keeps ordinary source files off provider paths.
+*/
+const RESERVED_EXTENSIONS = Object.freeze([
+	".astro",
+	".cjs",
+	".cts",
+	".js",
+	".json",
+	".json5",
+	".jsonc",
+	".jsx",
+	".mjs",
+	".mts",
+	".svelte",
+	".ts",
+	".tsx",
+	".vue"
+]);
+const RESERVED = new Set(RESERVED_EXTENSIONS);
+const IDENTIFIER = /^[a-z][a-z0-9-]*$/u;
+var ProviderProtocolError = class extends Error {
+	diagnostics;
+	constructor(diagnostics) {
+		const failures = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+		super(`the declared language providers cannot be indexed:\n${failures.map((diagnostic) => `- ${diagnostic.message}`).join("\n")}`);
+		this.name = "ProviderProtocolError";
+		this.diagnostics = diagnostics;
+	}
+};
+function defaultReadFile(path) {
+	return readFile(path, "utf8");
+}
+/**
+* Issuer-aware Node resolution. A host with a different module map (Yarn PnP)
+* injects `pnp.resolveRequest`, which has the same `(request, issuer)` shape.
+*/
+function createDefaultResolver() {
+	const requires = /* @__PURE__ */ new Map();
+	return (request, issuer) => {
+		let resolver = requires.get(issuer);
+		if (resolver === void 0) {
+			resolver = createRequire(issuer);
+			requires.set(issuer, resolver);
+		}
+		return resolver.resolve(request);
+	};
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJson(text, path) {
+	try {
+		return JSON.parse(String(text));
+	} catch (error) {
+		throw new Error(`${path} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function diagnostic(severity, code, message, details = {}) {
+	return {
+		severity,
+		code,
+		message,
+		...details
+	};
+}
+function isInside(directory, path) {
+	const offset = relative(directory, path);
+	return offset.length > 0 && !offset.startsWith("..") && !offset.startsWith(`${sep}`);
+}
+/** Union of the direct dependency fields, sorted for deterministic output. */
+function dependencyNames(manifest) {
+	const names = /* @__PURE__ */ new Set();
+	for (const field of DEPENDENCY_FIELDS) {
+		const declared = manifest?.[field];
+		if (!isPlainObject(declared)) continue;
+		for (const name of Object.keys(declared)) names.add(name);
+	}
+	return [...names].sort();
+}
+function providerDeclaration(manifest) {
+	const declaration = manifest?.oxc?.provider;
+	return isPlainObject(declaration) ? declaration : null;
+}
+function extensionOf(filePath) {
+	if (typeof filePath !== "string") return null;
+	const name = filePath.split(/[/\\]/u).at(-1) ?? "";
+	const dot = name.lastIndexOf(".");
+	if (dot <= 0) return null;
+	return name.slice(dot).toLowerCase();
+}
+function isReservedExtension(extension) {
+	return typeof extension === "string" && RESERVED.has(extension.toLowerCase());
+}
+/** The nearest ancestor directory of `start` that contains a package.json. */
+async function findProjectRoot(start = process.cwd(), options = {}) {
+	const readFile = options.readFile ?? defaultReadFile;
+	const from = resolve(start);
+	const filesystemRoot = parse(from).root;
+	let directory = from;
+	for (;;) try {
+		await readFile(join(directory, "package.json"), "utf8");
+		return directory;
+	} catch {
+		if (directory === filesystemRoot) throw new Error(`no package.json was found at or above ${from}`);
+		directory = dirname(directory);
+	}
+}
+function normalizeBinMap(manifest) {
+	if (typeof manifest.bin === "string") return typeof manifest.name === "string" ? { [manifest.name]: manifest.bin } : {};
+	return isPlainObject(manifest.bin) ? manifest.bin : {};
+}
+function moduleSpecifier(name, subpath) {
+	if (subpath === ".") return name;
+	return `${name}/${subpath.replace(/^\.\/?/u, "")}`;
+}
+function readCapabilities(declared, context) {
+	const capabilities = {};
+	if (!isPlainObject(declared)) return capabilities;
+	for (const capability of CAPABILITY_NAMES) {
+		const value = declared[capability];
+		if (value === void 0) continue;
+		const target = readCapabilityTarget(capability, value, context);
+		if (target !== null) capabilities[capability] = target;
+	}
+	return capabilities;
+}
+function readCapabilityTarget(capability, value, context) {
+	const { name, providerRoot, manifest, diagnostics, resolve: resolve$1, issuer } = context;
+	if (!isPlainObject(value)) {
+		diagnostics.push(diagnostic("warning", "invalid-capability", `package ${name} declares a non-object ${capability} capability`, {
+			packages: [name],
+			capability
+		}));
+		return null;
+	}
+	if (typeof value.bin === "string" && value.bin.length > 0) {
+		const declared = normalizeBinMap(manifest)[value.bin];
+		if (typeof declared !== "string" || declared.length === 0) {
+			diagnostics.push(diagnostic("warning", "invalid-capability", `package ${name} declares the ${capability} capability as bin "${value.bin}", which is not a key of its own bin map`, {
+				packages: [name],
+				capability
+			}));
+			return null;
+		}
+		const path = resolve(providerRoot, declared);
+		if (!isInside(providerRoot, path)) {
+			diagnostics.push(diagnostic("warning", "invalid-capability", `package ${name} declares the ${capability} capability outside its own package directory`, {
+				packages: [name],
+				capability
+			}));
+			return null;
+		}
+		return {
+			kind: "bin",
+			bin: value.bin,
+			path
+		};
+	}
+	if (typeof value.module === "string" && value.module.startsWith(".")) {
+		const specifier = moduleSpecifier(name, value.module);
+		let path = null;
+		try {
+			path = resolve$1(specifier, issuer);
+		} catch {
+			diagnostics.push(diagnostic("warning", "unresolved-capability", `package ${name} declares the ${capability} capability at ${specifier}, which its exports map does not resolve for this host`, {
+				packages: [name],
+				capability
+			}));
+		}
+		return {
+			kind: "module",
+			subpath: value.module,
+			specifier,
+			path
+		};
+	}
+	diagnostics.push(diagnostic("warning", "invalid-capability", `package ${name} declares a ${capability} capability that is neither an export subpath nor an own bin key`, {
+		packages: [name],
+		capability
+	}));
+	return null;
+}
+function readLanguages(declared, context) {
+	const { name, diagnostics } = context;
+	if (!Array.isArray(declared) || declared.length === 0) {
+		diagnostics.push(diagnostic("warning", "invalid-provider", `package ${name} declares no provider languages`, { packages: [name] }));
+		return [];
+	}
+	const languages = [];
+	for (const entry of declared) {
+		if (!isPlainObject(entry) || typeof entry.id !== "string" || !IDENTIFIER.test(entry.id)) {
+			diagnostics.push(diagnostic("warning", "invalid-provider", `package ${name} declares a language without a valid id`, { packages: [name] }));
+			continue;
+		}
+		const extensions = [];
+		for (const extension of Array.isArray(entry.extensions) ? entry.extensions : []) {
+			if (typeof extension !== "string" || extension.length < 2 || !extension.startsWith(".") || extension !== extension.toLowerCase() || /[\s/\\]/u.test(extension)) {
+				diagnostics.push(diagnostic("warning", "invalid-provider", `package ${name} declares the malformed extension ${JSON.stringify(extension)} for language ${entry.id}`, { packages: [name] }));
+				continue;
+			}
+			if (RESERVED.has(extension)) {
+				diagnostics.push(diagnostic("error", "reserved-extension", `package ${name} claims the reserved ${extension} extension, which protocol 1 keeps on the core toolchain`, {
+					packages: [name],
+					extension
+				}));
+				continue;
+			}
+			if (!extensions.includes(extension)) extensions.push(extension);
+		}
+		if (extensions.length === 0) continue;
+		languages.push({
+			id: entry.id,
+			extensions,
+			capabilities: readCapabilities(entry.capabilities, context)
+		});
+	}
+	return languages;
+}
+function readProvider(name, record, declaration, context) {
+	const { diagnostics, protocols } = context;
+	const { protocol, id } = declaration;
+	if (!Number.isInteger(protocol)) {
+		diagnostics.push(diagnostic("warning", "invalid-provider", `package ${name} declares a non-integer provider protocol`, { packages: [name] }));
+		return null;
+	}
+	if (!protocols.has(protocol)) {
+		diagnostics.push(diagnostic("warning", "unsupported-protocol", `package ${name} declares provider protocol ${protocol}, which this host does not support; it is ignored`, {
+			packages: [name],
+			protocol
+		}));
+		return null;
+	}
+	if (typeof id !== "string" || !IDENTIFIER.test(id)) {
+		diagnostics.push(diagnostic("warning", "invalid-provider", `package ${name} declares an invalid provider id ${JSON.stringify(id ?? null)}`, { packages: [name] }));
+		return null;
+	}
+	const languages = readLanguages(declaration.languages, {
+		...context,
+		name,
+		manifest: record.manifest,
+		providerRoot: record.root
+	});
+	if (languages.length === 0) return null;
+	return {
+		name,
+		version: typeof record.manifest.version === "string" ? record.manifest.version : null,
+		root: record.root,
+		manifest: record.manifestPath,
+		protocol,
+		id,
+		languages
+	};
+}
+/**
+* Read one candidate dependency's manifest.
+*
+* The two failure modes below look alike and are not alike. Resolution failing
+* means the package is simply not installed, which is ordinary and stays quiet;
+* an uninstalled optional dependency must never warn. A manifest that resolves
+* and then cannot be read or parsed is different: resolution already proved the
+* package is there, so failing to read it is a host or environment fault, and it
+* must never be mistaken for "this package is not a provider".
+*/
+async function readDependencyManifest(name, issuer, resolve, readFile, diagnostics) {
+	let manifestPath;
+	try {
+		manifestPath = resolve(`${name}/package.json`, issuer);
+	} catch {
+		return null;
+	}
+	let manifest;
+	try {
+		manifest = JSON.parse(String(await readFile(manifestPath, "utf8")));
+	} catch (error) {
+		diagnostics?.push(diagnostic("warning", "unreadable-manifest", `package ${name} resolved to ${manifestPath}, which this host could not read or parse: ${error instanceof Error ? error.message : String(error)}; a host with its own module map must supply a readFile that reads through the same layer`, {
+			packages: [name],
+			manifest: manifestPath
+		}));
+		return null;
+	}
+	if (!isPlainObject(manifest)) {
+		diagnostics?.push(diagnostic("warning", "unreadable-manifest", `package ${name} resolved to ${manifestPath}, which does not contain a JSON object`, {
+			packages: [name],
+			manifest: manifestPath
+		}));
+		return null;
+	}
+	return {
+		manifestPath,
+		root: dirname(manifestPath),
+		manifest
+	};
+}
+async function inspectAncestors(root, directNames, context) {
+	const { readFile, resolve, diagnostics } = context;
+	const filesystemRoot = parse(root).root;
+	let directory = root;
+	while (directory !== filesystemRoot) {
+		directory = dirname(directory);
+		const manifestPath = join(directory, "package.json");
+		let manifest;
+		try {
+			manifest = JSON.parse(String(await readFile(manifestPath, "utf8")));
+		} catch {
+			continue;
+		}
+		for (const name of dependencyNames(manifest)) {
+			if (directNames.has(name)) continue;
+			const record = await readDependencyManifest(name, manifestPath, resolve, readFile, diagnostics);
+			if (record === null || providerDeclaration(record.manifest) === null) continue;
+			diagnostics.push(diagnostic("warning", "ancestor-provider", `package ${name} declares a language provider and is a dependency of ${manifestPath}, but it is not a direct dependency of ${join(root, "package.json")}; it is not activated`, {
+				packages: [name],
+				manifest: manifestPath,
+				root: join(root, "package.json")
+			}));
+		}
+	}
+}
+/**
+* Build the provider index for one project root.
+*
+* `resolve(request, issuer)` and `readFile(path, encoding)` are injectable so a
+* host with a non-filesystem module map can supply its own. Fatal protocol
+* violations (a reserved extension, two providers claiming one extension, two
+* providers claiming one id) throw unless `throwOnError` is `false`; a report
+* command uses `false` to show every violation at once.
+*/
+async function discoverProviders(options = {}) {
+	const root = resolve(options.root ?? process.cwd());
+	const readFile = options.readFile ?? defaultReadFile;
+	const resolve$2 = options.resolve ?? createDefaultResolver();
+	const protocols = new Set(options.protocols ?? SUPPORTED_PROTOCOLS);
+	const throwOnError = options.throwOnError !== false;
+	const manifestPath = join(root, "package.json");
+	const diagnostics = [];
+	const names = dependencyNames(parseJson(await readFile(manifestPath, "utf8"), manifestPath));
+	const context = {
+		diagnostics,
+		protocols,
+		resolve: resolve$2,
+		readFile,
+		issuer: manifestPath
+	};
+	const declared = [];
+	for (const name of names) {
+		const record = await readDependencyManifest(name, manifestPath, resolve$2, readFile, diagnostics);
+		if (record === null) continue;
+		const declaration = providerDeclaration(record.manifest);
+		if (declaration === null) continue;
+		const provider = readProvider(name, record, declaration, context);
+		if (provider !== null) declared.push(provider);
+	}
+	const byIdentifier = /* @__PURE__ */ new Map();
+	for (const provider of declared) {
+		const group = byIdentifier.get(provider.id);
+		if (group === void 0) byIdentifier.set(provider.id, [provider]);
+		else group.push(provider);
+	}
+	const rejectedIdentifiers = /* @__PURE__ */ new Set();
+	for (const [id, group] of byIdentifier) {
+		if (group.length < 2) continue;
+		rejectedIdentifiers.add(id);
+		const packages = group.map((provider) => provider.name);
+		diagnostics.push(diagnostic("error", "duplicate-id", `packages ${packages.join(" and ")} both declare the provider id "${id}"`, {
+			packages,
+			id
+		}));
+	}
+	const providers = declared.filter((provider) => !rejectedIdentifiers.has(provider.id));
+	const claims = /* @__PURE__ */ new Map();
+	for (const provider of providers) for (const language of provider.languages) for (const extension of language.extensions) {
+		const claim = {
+			provider,
+			language
+		};
+		const group = claims.get(extension);
+		if (group === void 0) claims.set(extension, [claim]);
+		else group.push(claim);
+	}
+	const extensions = {};
+	for (const extension of [...claims.keys()].sort()) {
+		const group = claims.get(extension);
+		if (group.length > 1) {
+			const packages = group.map((claim) => claim.provider.name);
+			diagnostics.push(diagnostic("error", "extension-conflict", `packages ${packages.join(" and ")} both claim the ${extension} extension; protocol 1 never picks a winner`, {
+				packages,
+				extension
+			}));
+			continue;
+		}
+		const [{ provider, language }] = group;
+		extensions[extension] = {
+			extension,
+			package: provider.name,
+			providerId: provider.id,
+			providerRoot: provider.root,
+			language: language.id,
+			capabilities: language.capabilities
+		};
+	}
+	if (options.inspectAncestors !== false) await inspectAncestors(root, new Set(names), context);
+	const index = {
+		root,
+		providers,
+		extensions,
+		diagnostics
+	};
+	if (throwOnError && diagnostics.some((entry) => entry.severity === "error")) throw new ProviderProtocolError(diagnostics);
+	return index;
+}
+function providerExtensions(index) {
+	return Object.keys(index?.extensions ?? {}).sort();
+}
+function hasProviderErrors(index) {
+	return (index?.diagnostics ?? []).some((entry) => entry.severity === "error");
+}
+/**
+* Look up one capability for one file. Returns `null` for every extension the
+* index does not own, which is the fast path for ordinary source files.
+*/
+function resolveCapability(index, filePath, capability) {
+	const extension = extensionOf(filePath);
+	if (extension === null) return null;
+	const entry = index?.extensions?.[extension];
+	if (entry === void 0) return null;
+	const target = entry.capabilities?.[capability];
+	if (target === void 0) return null;
+	return {
+		package: entry.package,
+		providerId: entry.providerId,
+		providerRoot: entry.providerRoot,
+		language: entry.language,
+		extension,
+		capability,
+		...target
+	};
+}
+//#endregion
+export { CAPABILITY_NAMES, DEPENDENCY_FIELDS, PROTOCOL_VERSION, ProviderProtocolError, RESERVED_EXTENSIONS, SUPPORTED_PROTOCOLS, dependencyNames, discoverProviders, extensionOf, findProjectRoot, hasProviderErrors, isReservedExtension, providerDeclaration, providerExtensions, resolveCapability };

package/dist/providers-report.js

@@ -0,0 +1,49 @@
+import { CAPABILITY_NAMES, discoverProviders, findProjectRoot, hasProviderErrors } from "./provider-resolve.js";
+//#region src/providers-report.ts
+/**
+* Read-only audit of the language providers a project root activates.
+*
+* The report never writes a file, never mutates node_modules, and never runs a
+* dependency: it is the auditable counterpart to a host quietly executing a
+* provider it discovered.
+*/
+async function collectProviderReport(options = {}) {
+	const root = await findProjectRoot(options.projectRoot ?? process.cwd());
+	const index = await discoverProviders({
+		root,
+		throwOnError: false
+	});
+	return {
+		schemaVersion: 1,
+		ok: !hasProviderErrors(index),
+		root: index.root,
+		providers: index.providers,
+		extensions: index.extensions,
+		diagnostics: index.diagnostics
+	};
+}
+function capabilityLabel(capability) {
+	if (capability.kind === "bin") return `bin ${capability.bin} -> ${capability.path}`;
+	return `module ${capability.specifier}${capability.path === null ? " (unresolved)" : ""}`;
+}
+function formatProviderReport(report) {
+	const lines = [`project root: ${report.root}`];
+	if (report.providers.length === 0) lines.push("no language providers are declared by the direct dependencies");
+	for (const provider of report.providers) {
+		lines.push(`${provider.name}${provider.version === null ? "" : `@${provider.version}`} (provider ${provider.id}, protocol ${provider.protocol})`);
+		for (const language of provider.languages) {
+			lines.push(`  language ${language.id}: ${language.extensions.join(" ")}`);
+			for (const capability of CAPABILITY_NAMES) {
+				const target = language.capabilities[capability];
+				if (target === void 0) continue;
+				lines.push(`    ${capability}: ${capabilityLabel(target)}`);
+			}
+		}
+	}
+	const routed = Object.keys(report.extensions).sort();
+	if (routed.length > 0) lines.push(`routed extensions: ${routed.map((extension) => `${extension} -> ${report.extensions[extension].package}`).join(", ")}`);
+	for (const diagnostic of report.diagnostics) lines.push(`${diagnostic.severity}: ${diagnostic.message}`);
+	return `${lines.join("\n")}\n`;
+}
+//#endregion
+export { collectProviderReport, formatProviderReport };