everything-dev 1.53.1 → 2.0.0-rc.0

package/dist/api-contract.cjs

@@ -1,10 +1,152 @@
 const require_auth_types_gen = require('./auth-types-gen.cjs');
 const require_http_client = require('./http-client.cjs');
+const require_service_descriptor = require('./service-descriptor.cjs');
 let node_fs = require("node:fs");
 let node_path = require("node:path");
+let effect = require("effect");
 let node_crypto = require("node:crypto");
 
 //#region src/api-contract.ts
+var ApiManifestFetchError = class extends effect.Schema.TaggedError()("ApiManifestFetchError", {
+	url: effect.Schema.String,
+	message: effect.Schema.String
+}) {};
+var ApiManifestFormatError = class extends effect.Schema.TaggedError()("ApiManifestFormatError", {
+	url: effect.Schema.String,
+	message: effect.Schema.String
+}) {};
+var MissingContractTypesError = class extends effect.Schema.TaggedError()("MissingContractTypesError", {
+	pluginName: effect.Schema.String,
+	message: effect.Schema.String
+}) {};
+var ContractTypesFetchError = class extends effect.Schema.TaggedError()("ContractTypesFetchError", {
+	url: effect.Schema.String,
+	message: effect.Schema.String
+}) {};
+var ContractTypesChecksumError = class extends effect.Schema.TaggedError()("ContractTypesChecksumError", {
+	url: effect.Schema.String,
+	message: effect.Schema.String
+}) {};
+var AuthExportFetchError = class extends effect.Schema.TaggedError()("AuthExportFetchError", {
+	url: effect.Schema.String,
+	message: effect.Schema.String
+}) {};
+var ApiContractResolver = class ApiContractResolver extends effect.Context.Service()("everything-dev/api-contract/ApiContractResolver") {
+	static layer = effect.Layer.effect(ApiContractResolver, effect.Effect.sync(() => {
+		const manifest = effect.Effect.fn("ApiContractResolver.manifest")(function* (apiBaseUrl) {
+			const url = getApiPluginManifestUrl(apiBaseUrl);
+			const fetched = yield* effect.Effect.tryPromise({
+				try: () => require_http_client.fetchJsonOrNull(url, { retries: 2 }),
+				catch: () => new ApiManifestFetchError({
+					url,
+					message: `Failed to fetch API plugin manifest from ${url}`
+				})
+			});
+			if (!fetched) return yield* new ApiManifestFetchError({
+				url,
+				message: `Failed to fetch API plugin manifest from ${url}`
+			});
+			if (fetched.schemaVersion !== 1 || fetched.kind !== "every-plugin/manifest") return yield* new ApiManifestFormatError({
+				url,
+				message: "Unsupported API plugin manifest format"
+			});
+			return fetched;
+		});
+		const writeContractTypes = effect.Effect.fn("ApiContractResolver.writeContractTypes")(function* (opts) {
+			const contractResponse = yield* effect.Effect.tryPromise({
+				try: () => require_http_client.fetchResponse(opts.contractUrl),
+				catch: () => new ContractTypesFetchError({
+					url: opts.contractUrl,
+					message: `Failed to fetch contract types from ${opts.contractUrl}`
+				})
+			});
+			if (!contractResponse.ok) return yield* new ContractTypesFetchError({
+				url: opts.contractUrl,
+				message: `Failed to fetch contract types from ${opts.contractUrl}: ${contractResponse.status} ${contractResponse.statusText}`
+			});
+			const contractTypes = yield* effect.Effect.tryPromise({
+				try: () => contractResponse.text(),
+				catch: () => new ContractTypesFetchError({
+					url: opts.contractUrl,
+					message: `Failed to fetch contract types from ${opts.contractUrl}`
+				})
+			});
+			if (opts.manifest.contract?.types.sha256 && opts.manifest.contract.types.sha256 !== sha256(contractTypes)) return yield* new ContractTypesChecksumError({
+				url: opts.contractUrl,
+				message: "Fetched contract types failed checksum verification"
+			});
+			const generatedPath = (0, node_path.join)(opts.runtimeDir, opts.generatedSubdir, "contract.d.ts");
+			yield* effect.Effect.sync(() => {
+				(0, node_fs.mkdirSync)((0, node_path.dirname)(generatedPath), { recursive: true });
+				writeFileIfChanged(generatedPath, contractTypes);
+			});
+			return {
+				key: opts.name,
+				importName: `${sanitizeIdentifier(opts.name)}Contract`,
+				sourceFilePath: generatedPath,
+				generatedPath
+			};
+		});
+		const contractSource = effect.Effect.fn("ApiContractResolver.contractSource")(function* (opts) {
+			const fetchedManifest = yield* manifest(opts.baseUrl);
+			if (!fetchedManifest.contract) return yield* new MissingContractTypesError({
+				pluginName: fetchedManifest.plugin.name,
+				message: `Plugin manifest for ${fetchedManifest.plugin.name} does not advertise contract types`
+			});
+			const contractUrl = `${trimTrailingSlash(opts.baseUrl)}/${fetchedManifest.contract.types.path.replace(/^\.\//, "")}`;
+			return yield* writeContractTypes({
+				contractUrl,
+				manifest: fetchedManifest,
+				runtimeDir: opts.runtimeDir,
+				generatedSubdir: opts.generatedSubdir,
+				name: opts.name
+			});
+		});
+		const authExportTypes = effect.Effect.fn("ApiContractResolver.authExportTypes")(function* (opts) {
+			const entry = (opts.manifest.additionalExports ?? []).find((candidate) => candidate.path.includes("auth-export") || candidate.path.endsWith("auth-export.d.ts"));
+			if (!entry) return null;
+			const exportUrl = `${trimTrailingSlash(opts.baseUrl)}/${entry.path.replace(/^\.\//, "")}`;
+			const response = yield* effect.Effect.tryPromise({
+				try: () => require_http_client.fetchResponse(exportUrl),
+				catch: () => new AuthExportFetchError({
+					url: exportUrl,
+					message: `Failed to fetch auth export types from ${exportUrl}`
+				})
+			});
+			if (!response.ok) return yield* new AuthExportFetchError({
+				url: exportUrl,
+				message: `Failed to fetch auth export types from ${exportUrl}: ${response.status}`
+			});
+			const content = yield* effect.Effect.tryPromise({
+				try: () => response.text(),
+				catch: () => new AuthExportFetchError({
+					url: exportUrl,
+					message: `Failed to fetch auth export types from ${exportUrl}`
+				})
+			});
+			if (entry.sha256 && entry.sha256 !== sha256(content)) return yield* new AuthExportFetchError({
+				url: exportUrl,
+				message: `Auth export types checksum mismatch for ${exportUrl}`
+			});
+			const generatedPath = (0, node_path.join)(opts.runtimeDir, "auth", "auth-export.d.ts");
+			yield* effect.Effect.sync(() => {
+				(0, node_fs.mkdirSync)((0, node_path.dirname)(generatedPath), { recursive: true });
+				writeFileIfChanged(generatedPath, content);
+			});
+			return generatedPath;
+		});
+		return ApiContractResolver.of({
+			manifest,
+			contractSource,
+			authExportTypes
+		});
+	}));
+};
+let resolverRuntime = null;
+function getResolver() {
+	if (!resolverRuntime) resolverRuntime = effect.ManagedRuntime.make(ApiContractResolver.layer);
+	return resolverRuntime;
+}
 function sha256(input) {
 	return (0, node_crypto.createHash)("sha256").update(input).digest("hex");
 }
@@ -29,63 +171,53 @@ function getApiPluginManifestUrl(apiBaseUrl) {
 	return `${trimTrailingSlash(apiBaseUrl)}/plugin.manifest.json`;
 }
 async function fetchApiPluginManifest(apiBaseUrl) {
-	const url = getApiPluginManifestUrl(apiBaseUrl);
-	const manifest = await require_http_client.fetchJsonOrNull(url, { retries: 0 });
-	if (!manifest) throw new Error(`Failed to fetch API plugin manifest from ${url}`);
-	if (manifest.schemaVersion !== 1 || manifest.kind !== "every-plugin/manifest") throw new Error("Unsupported API plugin manifest format");
-	return manifest;
+	return getResolver().runPromise(effect.Effect.gen(function* () {
+		return yield* (yield* ApiContractResolver).manifest(apiBaseUrl);
+	})).catch((error) => {
+		throw new Error(error.message);
+	});
 }
 function localApiContractSource(configDir) {
+	const sourcePath = (0, node_path.join)(configDir, "api", "src", "contract.ts");
+	if (!(0, node_fs.existsSync)(sourcePath)) throw new Error(`local api contract not found at api/src/contract.ts — restore the file or configure a reachable api URL`);
 	return {
 		key: "api",
 		importName: "BaseApiContract",
-		sourceFilePath: (0, node_path.join)(configDir, "api", "src", "contract.ts")
+		sourceFilePath: sourcePath
 	};
 }
 function localAuthContractSource(configDir) {
+	const sourcePath = (0, node_path.join)(configDir, "plugins", "auth", "src", "contract.ts");
+	if (!(0, node_fs.existsSync)(sourcePath)) throw new Error(`local auth contract not found at plugins/auth/src/contract.ts — restore the file or configure a reachable auth URL`);
 	return {
 		key: "auth",
 		importName: "authContract",
-		sourceFilePath: (0, node_path.join)(configDir, "plugins", "auth", "src", "contract.ts")
+		sourceFilePath: sourcePath
 	};
 }
 async function remoteContractSource(opts) {
-	const manifest = await fetchApiPluginManifest(opts.baseUrl);
-	if (!manifest.contract) throw new Error(`Plugin manifest for ${manifest.plugin.name} does not advertise contract types`);
-	const contractUrl = `${trimTrailingSlash(opts.baseUrl)}/${manifest.contract.types.path.replace(/^\.\//, "")}`;
-	const contractResponse = await require_http_client.fetchResponse(contractUrl);
-	if (!contractResponse.ok) throw new Error(`Failed to fetch contract types from ${contractUrl}: ${contractResponse.status} ${contractResponse.statusText}`);
-	const contractTypes = await contractResponse.text();
-	if (manifest.contract.types.sha256 && manifest.contract.types.sha256 !== sha256(contractTypes)) throw new Error("Fetched contract types failed checksum verification");
-	const generatedPath = (0, node_path.join)(opts.runtimeDir, opts.generatedSubdir, "contract.d.ts");
-	(0, node_fs.mkdirSync)((0, node_path.dirname)(generatedPath), { recursive: true });
-	writeFileIfChanged(generatedPath, contractTypes);
-	return {
-		key: opts.name,
-		importName: `${sanitizeIdentifier(opts.name)}Contract`,
-		sourceFilePath: generatedPath,
-		generatedPath
-	};
+	return getResolver().runPromise(effect.Effect.gen(function* () {
+		return yield* (yield* ApiContractResolver).contractSource({
+			baseUrl: opts.baseUrl,
+			runtimeDir: opts.runtimeDir,
+			name: opts.name,
+			generatedSubdir: opts.generatedSubdir
+		});
+	})).catch((error) => {
+		throw new Error(error.message);
+	});
 }
 async function fetchAuthExportTypes(opts) {
-	if (!opts.manifest.additionalExports || opts.manifest.additionalExports.length === 0) return null;
-	const authExportEntry = opts.manifest.additionalExports.find((entry) => entry.path.includes("auth-export") || entry.path.endsWith("auth-export.d.ts"));
-	if (!authExportEntry) return null;
-	const exportUrl = `${trimTrailingSlash(opts.baseUrl)}/${authExportEntry.path.replace(/^\.\//, "")}`;
-	const response = await require_http_client.fetchResponse(exportUrl);
-	if (!response.ok) {
-		console.warn(`[API Contract] Failed to fetch auth export types from ${exportUrl}: ${response.status}`);
-		return null;
-	}
-	const content = await response.text();
-	if (authExportEntry.sha256 && authExportEntry.sha256 !== sha256(content)) {
-		console.warn(`[API Contract] Auth export types checksum mismatch for ${exportUrl}`);
+	return getResolver().runPromise(effect.Effect.gen(function* () {
+		return yield* (yield* ApiContractResolver).authExportTypes({
+			baseUrl: opts.baseUrl,
+			runtimeDir: opts.runtimeDir,
+			manifest: opts.manifest
+		});
+	})).catch((error) => {
+		console.warn(`[API Contract] ${error.message}`);
 		return null;
-	}
-	const generatedPath = (0, node_path.join)(opts.runtimeDir, "auth", "auth-export.d.ts");
-	(0, node_fs.mkdirSync)((0, node_path.dirname)(generatedPath), { recursive: true });
-	writeFileIfChanged(generatedPath, content);
-	return generatedPath;
+	});
 }
 async function resolveContractSource(opts) {
 	if (opts.key === "api") {
@@ -120,7 +252,7 @@ async function resolveContractSource(opts) {
 	});
 }
 function writePluginClientGen(opts) {
-	const pluginSrcDir = (0, node_path.join)(opts.configDir, "plugins", opts.pluginKey, "src");
+	const pluginSrcDir = (0, node_path.join)(opts.localPath, "src");
 	if (!(0, node_fs.existsSync)(pluginSrcDir)) return;
 	const targetPath = (0, node_path.join)(pluginSrcDir, "lib", "plugins-client.gen.ts");
 	const lines = [];
@@ -128,15 +260,16 @@ function writePluginClientGen(opts) {
 		const importPath = toImportPath(targetPath, source.sourceFilePath);
 		lines.push(`import type { ContractType as ${source.importName} } from "${importPath}";`);
 	}
-	lines.push("import type { ContractRouterClient, AnyContractRouter } from \"@orpc/contract\";");
-	lines.push("type ClientFactory<C extends AnyContractRouter> = (context?: Record<string, unknown>) => ContractRouterClient<C>;");
+	lines.push("import type { RouterContractClient, RouterContract } from \"@orpc/contract\";");
+	lines.push("import type { ContractedRouter } from \"@orpc/server\";");
+	lines.push("type PluginClientEntry<C extends RouterContract> = {\n  client: (context?: Record<string, unknown>) => RouterContractClient<C>;\n  router: ContractedRouter<C, any>;\n};");
 	lines.push("");
 	if (opts.depSources.length === 0) lines.push("export type PluginsClient = Record<string, never>;");
 	else {
 		lines.push("export type PluginsClient = {");
 		for (const source of opts.depSources) {
 			const key = /^[$A-Z_][0-9A-Z_$]*$/i.test(source.key) ? source.key : JSON.stringify(source.key);
-			lines.push(`  ${key}: ClientFactory<${source.importName}>;`);
+			lines.push(`  ${key}: PluginClientEntry<${source.importName}>;`);
 		}
 		lines.push("};");
 	}
@@ -183,19 +316,20 @@ function writeGeneratedFiles(opts) {
 			const importPath = toImportPath(pluginsClientPath, source.sourceFilePath);
 			pluginsClientLines.push(`import type { ContractType as ${source.importName} } from "${importPath}";`);
 		}
-		pluginsClientLines.push("import type { ContractRouterClient, AnyContractRouter } from \"@orpc/contract\";");
-		pluginsClientLines.push("type ClientFactory<C extends AnyContractRouter> = (context?: Record<string, unknown>) => ContractRouterClient<C>;");
+		pluginsClientLines.push("import type { RouterContractClient, RouterContract } from \"@orpc/contract\";");
+		pluginsClientLines.push("import type { ContractedRouter } from \"@orpc/server\";");
+		pluginsClientLines.push("type PluginClientEntry<C extends RouterContract> = {\n  client: (context?: Record<string, unknown>) => RouterContractClient<C>;\n  router: ContractedRouter<C, any>;\n};");
 		pluginsClientLines.push("");
 		if (apiDepSources.length === 0 && unresolvedDepKeys.length === 0) pluginsClientLines.push("export type PluginsClient = Record<string, never>;");
 		else {
 			pluginsClientLines.push("export type PluginsClient = {");
 			for (const source of apiDepSources) {
 				const key = /^[$A-Z_][0-9A-Z_$]*$/i.test(source.key) ? source.key : JSON.stringify(source.key);
-				pluginsClientLines.push(`  ${key}: ClientFactory<${source.importName}>;`);
+				pluginsClientLines.push(`  ${key}: PluginClientEntry<${source.importName}>;`);
 			}
 			for (const key of unresolvedDepKeys) {
 				const keyStr = /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : JSON.stringify(key);
-				pluginsClientLines.push(`  ${keyStr}?: ClientFactory<AnyContractRouter>;`);
+				pluginsClientLines.push(`  ${keyStr}?: PluginClientEntry<RouterContract>;`);
 			}
 			pluginsClientLines.push("};");
 		}
@@ -208,13 +342,23 @@ function writeGeneratedFiles(opts) {
 		key: "auth"
 	});
 	for (const pluginKey of opts.pluginKeys) {
-		const deps = opts.pluginDependsOn?.[pluginKey];
-		if (!deps?.length) continue;
-		const depSources = deps.map((depKey) => allSourcesForLookup.find((s) => s.key === depKey)).filter((s) => Boolean(s));
+		const localPath = opts.pluginLocalPaths?.[pluginKey];
+		if (!localPath) continue;
+		const depSources = (opts.pluginDependsOn?.[pluginKey] ?? []).map((depKey) => allSourcesForLookup.find((s) => s.key === depKey)).filter((s) => Boolean(s));
 		writePluginClientGen({
 			configDir: opts.configDir,
 			pluginKey,
-			depSources
+			depSources,
+			localPath
+		});
+	}
+	if (opts.authLocalPath) {
+		const depSources = (opts.authDependsOn ?? []).map((depKey) => allSourcesForLookup.find((s) => s.key === depKey)).filter((s) => Boolean(s));
+		writePluginClientGen({
+			configDir: opts.configDir,
+			pluginKey: "auth",
+			depSources,
+			localPath: opts.authLocalPath
 		});
 	}
 	const authTypeTargets = [(0, node_path.join)(opts.configDir, "ui", "src", "lib", "auth-types.gen.ts")];
@@ -223,8 +367,10 @@ function writeGeneratedFiles(opts) {
 	const hostLibDir = (0, node_path.join)(opts.configDir, "host", "src", "lib");
 	if ((0, node_fs.existsSync)((0, node_path.join)(opts.configDir, "host", "src"))) authTypeTargets.push((0, node_path.join)(hostLibDir, "auth-types.gen.ts"));
 	for (const key of opts.pluginKeys) {
-		const pluginLibDir = (0, node_path.join)(opts.configDir, "plugins", key, "src", "lib");
-		if ((0, node_fs.existsSync)((0, node_path.join)(opts.configDir, "plugins", key, "src"))) authTypeTargets.push((0, node_path.join)(pluginLibDir, "auth-types.gen.ts"));
+		const localPath = opts.pluginLocalPaths?.[key];
+		if (!localPath) continue;
+		const pluginSrcDir = (0, node_path.join)(localPath, "src");
+		if ((0, node_fs.existsSync)(pluginSrcDir)) authTypeTargets.push((0, node_path.join)(pluginSrcDir, "lib", "auth-types.gen.ts"));
 	}
 	if (opts.authExportPath) for (const authTypesPath of authTypeTargets) {
 		const exportImportPath = toImportPath(authTypesPath, opts.authExportPath);
@@ -232,17 +378,44 @@ function writeGeneratedFiles(opts) {
 		(0, node_fs.mkdirSync)((0, node_path.dirname)(authTypesPath), { recursive: true });
 		writeFileIfChanged(authTypesPath, require_auth_types_gen.buildAuthTypesGenContent(exportImportPath, contractImportPath));
 	}
-	else if (opts.authSource) for (const authTypesPath of authTypeTargets) {
-		const exportImportPath = toImportPath(authTypesPath, (0, node_path.join)(opts.configDir, ".bos", "generated", "auth", "auth-export.d.ts"));
-		const contractImportPath = toImportPath(authTypesPath, (0, node_path.join)(opts.configDir, ".bos", "generated", "auth", "contract.d.ts"));
-		(0, node_fs.mkdirSync)((0, node_path.dirname)(authTypesPath), { recursive: true });
-		writeFileIfChanged(authTypesPath, require_auth_types_gen.buildAuthTypesGenContent(exportImportPath, contractImportPath));
+	else if (opts.authSource) {
+		const generatedAuthExportPath = (0, node_path.join)(opts.configDir, ".bos", "generated", "auth", "auth-export.d.ts");
+		(0, node_fs.mkdirSync)((0, node_path.dirname)(generatedAuthExportPath), { recursive: true });
+		if (!(0, node_fs.existsSync)(generatedAuthExportPath)) writeFileIfChanged(generatedAuthExportPath, require_auth_types_gen.buildAuthExportStub());
+		for (const authTypesPath of authTypeTargets) {
+			const exportImportPath = toImportPath(authTypesPath, generatedAuthExportPath);
+			const contractImportPath = toImportPath(authTypesPath, (0, node_path.join)(opts.configDir, ".bos", "generated", "auth", "contract.d.ts"));
+			(0, node_fs.mkdirSync)((0, node_path.dirname)(authTypesPath), { recursive: true });
+			writeFileIfChanged(authTypesPath, require_auth_types_gen.buildAuthTypesGenContent(exportImportPath, contractImportPath));
+		}
+	}
+	const localPluginKeys = new Set(Object.keys(opts.pluginLocalPaths ?? {}));
+	if (opts.authLocalPath) localPluginKeys.add("auth");
+	const pluginsRoot = (0, node_path.join)(opts.configDir, "plugins");
+	if ((0, node_fs.existsSync)(pluginsRoot)) for (const entry of (0, node_fs.readdirSync)(pluginsRoot, { withFileTypes: true })) {
+		if (!entry.isDirectory() || entry.name.startsWith("_") || localPluginKeys.has(entry.name)) continue;
+		for (const genName of ["plugins-client.gen.ts", "auth-types.gen.ts"]) {
+			const genPath = (0, node_path.join)(pluginsRoot, entry.name, "src", "lib", genName);
+			if ((0, node_fs.existsSync)(genPath)) (0, node_fs.rmSync)(genPath);
+		}
+	}
+	const generatedPluginsRoot = (0, node_path.join)(opts.configDir, ".bos", "generated", "plugins");
+	if ((0, node_fs.existsSync)(generatedPluginsRoot)) {
+		const configuredKeys = new Set(opts.sources.map((source) => source.key));
+		for (const entry of (0, node_fs.readdirSync)(generatedPluginsRoot, { withFileTypes: true })) {
+			if (!entry.isDirectory() || configuredKeys.has(entry.name)) continue;
+			(0, node_fs.rmSync)((0, node_path.join)(generatedPluginsRoot, entry.name), {
+				recursive: true,
+				force: true
+			});
+		}
 	}
 	return uiContractPath;
 }
 async function syncApiContractBridge(opts) {
 	const runtimeDir = (0, node_path.join)(opts.configDir, ".bos", "generated");
-	const pluginEntries = Object.entries(opts.runtimeConfig.plugins ?? {}).sort(([a], [b]) => a.localeCompare(b));
+	const isAuthMirrorEntry = (key, plugin) => require_service_descriptor.isAuthMirrorPluginEntry(opts.runtimeConfig.auth, key, plugin);
+	const pluginEntries = Object.entries(opts.runtimeConfig.plugins ?? {}).filter(([key, plugin]) => !isAuthMirrorEntry(key, plugin)).sort(([a], [b]) => a.localeCompare(b));
 	const sources = [];
 	const status = [];
 	let manifest = null;
@@ -372,7 +545,12 @@ async function syncApiContractBridge(opts) {
 	if (apiStatus?.source === "failed") throw new Error(`Cannot generate contract types without api contract: ${apiStatus.error ?? "unknown error"}`);
 	const allPluginKeys = pluginEntries.filter(([key]) => !excludedPluginKeys.has(key)).map(([key]) => key);
 	const pluginDependsOn = {};
-	for (const [key, plugin] of pluginEntries) if (!excludedPluginKeys.has(key) && plugin.dependsOn?.length) pluginDependsOn[key] = plugin.dependsOn;
+	const pluginLocalPaths = {};
+	for (const [key, plugin] of pluginEntries) {
+		if (excludedPluginKeys.has(key)) continue;
+		if (plugin.dependsOn?.length) pluginDependsOn[key] = plugin.dependsOn;
+		if (plugin.localPath) pluginLocalPaths[key] = plugin.localPath;
+	}
 	writeGeneratedFiles({
 		configDir: opts.configDir,
 		sources,
@@ -380,7 +558,10 @@ async function syncApiContractBridge(opts) {
 		authSource,
 		authExportPath,
 		apiDependsOn: opts.runtimeConfig.api.dependsOn,
-		pluginDependsOn
+		pluginDependsOn,
+		pluginLocalPaths,
+		authLocalPath: opts.runtimeConfig.auth?.source === "local" ? opts.runtimeConfig.auth.localPath : void 0,
+		authDependsOn: opts.runtimeConfig.auth?.dependsOn
 	});
 	if (opts.runtimeConfig.api.source !== "local") manifest = await fetchApiPluginManifest(opts.apiBaseUrl);
 	return {
@@ -393,6 +574,13 @@ async function syncApiContractBridge(opts) {
 }
 
 //#endregion
+exports.ApiContractResolver = ApiContractResolver;
+exports.ApiManifestFetchError = ApiManifestFetchError;
+exports.ApiManifestFormatError = ApiManifestFormatError;
+exports.AuthExportFetchError = AuthExportFetchError;
+exports.ContractTypesChecksumError = ContractTypesChecksumError;
+exports.ContractTypesFetchError = ContractTypesFetchError;
+exports.MissingContractTypesError = MissingContractTypesError;
 exports.fetchApiPluginManifest = fetchApiPluginManifest;
 exports.syncApiContractBridge = syncApiContractBridge;
 exports.writeGeneratedFiles = writeGeneratedFiles;