@backstage/config-loader 1.9.1 → 1.9.2

package/dist/index.cjs.js

@@ -1,1653 +1,25 @@
 'use strict';
 
-var Ajv = require('ajv');
-var mergeAllOf = require('json-schema-merge-allof');
-var traverse = require('json-schema-traverse');
-var config = require('@backstage/config');
-var fs = require('fs-extra');
-var os = require('os');
-var path = require('path');
-var errors = require('@backstage/errors');
-var parseArgs = require('minimist');
-var chokidar = require('chokidar');
-var yaml = require('yaml');
-var types = require('@backstage/types');
-var isEqual = require('lodash/isEqual');
-var fetch = require('node-fetch');
-var cliCommon = require('@backstage/cli-common');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-var Ajv__default = /*#__PURE__*/_interopDefaultCompat(Ajv);
-var mergeAllOf__default = /*#__PURE__*/_interopDefaultCompat(mergeAllOf);
-var traverse__default = /*#__PURE__*/_interopDefaultCompat(traverse);
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-var parseArgs__default = /*#__PURE__*/_interopDefaultCompat(parseArgs);
-var chokidar__default = /*#__PURE__*/_interopDefaultCompat(chokidar);
-var yaml__default = /*#__PURE__*/_interopDefaultCompat(yaml);
-var isEqual__default = /*#__PURE__*/_interopDefaultCompat(isEqual);
-var fetch__default = /*#__PURE__*/_interopDefaultCompat(fetch);
-
-const CONFIG_VISIBILITIES = ["frontend", "backend", "secret"];
-const DEFAULT_CONFIG_VISIBILITY = "backend";
-
-function normalizeAjvPath(path) {
-  return path.replace(/~1/g, "/").replace(/\['?(.*?)'?\]/g, (_, segment) => `/${segment}`);
-}
-
-const inheritedVisibility = Symbol("inherited-visibility");
-function compileConfigSchemas(schemas, options) {
-  const visibilityByDataPath = /* @__PURE__ */ new Map();
-  const deepVisibilityByDataPath = /* @__PURE__ */ new Map();
-  const deprecationByDataPath = /* @__PURE__ */ new Map();
-  const ajv = new Ajv__default.default({
-    allErrors: true,
-    allowUnionTypes: true,
-    coerceTypes: true,
-    schemas: {
-      "https://backstage.io/schema/config-v1": true
-    }
-  }).addKeyword({
-    keyword: "visibility",
-    metaSchema: {
-      type: "string",
-      enum: CONFIG_VISIBILITIES
-    },
-    compile(visibility) {
-      return (_data, context) => {
-        if (context?.instancePath === void 0) {
-          return false;
-        }
-        if (visibility && visibility !== "backend") {
-          const normalizedPath = normalizeAjvPath(context.instancePath);
-          visibilityByDataPath.set(normalizedPath, visibility);
-        }
-        return true;
-      };
-    }
-  }).addKeyword({
-    keyword: "deepVisibility",
-    metaSchema: {
-      type: "string",
-      /**
-       * Disallow 'backend' deepVisibility to prevent cases of permission escaping.
-       *
-       * Something like:
-       * - deepVisibility secret -> backend -> frontend.
-       * - deepVisibility secret -> backend -> visibility frontend.
-       */
-      enum: ["frontend", "secret"]
-    },
-    compile(visibility) {
-      return (_data, context) => {
-        if (context?.instancePath === void 0) {
-          return false;
-        }
-        if (visibility) {
-          const normalizedPath = normalizeAjvPath(context.instancePath);
-          deepVisibilityByDataPath.set(normalizedPath, visibility);
-        }
-        return true;
-      };
-    }
-  }).removeKeyword("deprecated").addKeyword({
-    keyword: "deprecated",
-    metaSchema: { type: "string" },
-    compile(deprecationDescription) {
-      return (_data, context) => {
-        if (context?.instancePath === void 0) {
-          return false;
-        }
-        const normalizedPath = normalizeAjvPath(context.instancePath);
-        deprecationByDataPath.set(normalizedPath, deprecationDescription);
-        return true;
-      };
-    }
-  });
-  for (const schema of schemas) {
-    try {
-      ajv.compile(schema.value);
-    } catch (error) {
-      throw new Error(`Schema at ${schema.path} is invalid, ${error}`);
-    }
-  }
-  const merged = mergeConfigSchemas(schemas.map((_) => _.value));
-  traverse__default.default(
-    merged,
-    (schema, jsonPtr, _1, _2, _3, parentSchema) => {
-      schema[inheritedVisibility] ??= schema?.deepVisibility ?? parentSchema?.[inheritedVisibility];
-      if (schema[inheritedVisibility]) {
-        const values = [
-          schema.visibility,
-          schema[inheritedVisibility],
-          parentSchema?.[inheritedVisibility]
-        ];
-        const hasFrontend = values.some((e) => e === "frontend");
-        const hasSecret = values.some((e) => e === "secret");
-        if (hasFrontend && hasSecret) {
-          throw new Error(
-            `Config schema visibility is both 'frontend' and 'secret' for ${jsonPtr}`
-          );
-        }
-      }
-      if (options?.noUndeclaredProperties) {
-        if (schema?.type === "object") {
-          schema.additionalProperties ||= false;
-        }
-      }
-    }
-  );
-  const validate = ajv.compile(merged);
-  const visibilityBySchemaPath = /* @__PURE__ */ new Map();
-  traverse__default.default(merged, (schema, path) => {
-    if (schema.visibility && schema.visibility !== "backend") {
-      visibilityBySchemaPath.set(normalizeAjvPath(path), schema.visibility);
-    }
-    if (schema.deepVisibility) {
-      visibilityBySchemaPath.set(normalizeAjvPath(path), schema.deepVisibility);
-    }
-  });
-  return (configs) => {
-    const config$1 = config.ConfigReader.fromConfigs(configs).getOptional();
-    visibilityByDataPath.clear();
-    deepVisibilityByDataPath.clear();
-    const valid = validate(config$1);
-    if (!valid) {
-      return {
-        errors: validate.errors ?? [],
-        visibilityByDataPath: new Map(visibilityByDataPath),
-        deepVisibilityByDataPath: new Map(deepVisibilityByDataPath),
-        visibilityBySchemaPath,
-        deprecationByDataPath
-      };
-    }
-    return {
-      visibilityByDataPath: new Map(visibilityByDataPath),
-      deepVisibilityByDataPath: new Map(deepVisibilityByDataPath),
-      visibilityBySchemaPath,
-      deprecationByDataPath
-    };
-  };
-}
-function mergeConfigSchemas(schemas) {
-  const merged = mergeAllOf__default.default(
-    { allOf: schemas },
-    {
-      // JSONSchema is typically subtractive, as in it always reduces the set of allowed
-      // inputs through constraints. This changes the object property merging to be additive
-      // rather than subtractive.
-      ignoreAdditionalProperties: true,
-      resolvers: {
-        // This ensures that the visibilities across different schemas are sound, and
-        // selects the most specific visibility for each path.
-        visibility(values, path) {
-          const hasFrontend = values.some((_) => _ === "frontend");
-          const hasSecret = values.some((_) => _ === "secret");
-          if (hasFrontend && hasSecret) {
-            throw new Error(
-              `Config schema visibility is both 'frontend' and 'secret' for ${path.join(
-                "/"
-              )}`
-            );
-          } else if (hasFrontend) {
-            return "frontend";
-          } else if (hasSecret) {
-            return "secret";
-          }
-          return "backend";
-        }
-      }
-    }
-  );
-  return merged;
-}
-
-const req = typeof __non_webpack_require__ === "undefined" ? require : __non_webpack_require__;
-async function collectConfigSchemas(packageNames, packagePaths) {
-  const schemas = new Array();
-  const tsSchemaPaths = new Array();
-  const visitedPackageVersions = /* @__PURE__ */ new Map();
-  const currentDir = await fs__default.default.realpath(process.cwd());
-  async function processItem(item) {
-    let pkgPath = item.packagePath;
-    if (pkgPath) {
-      const pkgExists = await fs__default.default.pathExists(pkgPath);
-      if (!pkgExists) {
-        return;
-      }
-    } else if (item.name) {
-      const { name, parentPath } = item;
-      try {
-        pkgPath = req.resolve(
-          `${name}/package.json`,
-          parentPath && {
-            paths: [parentPath]
-          }
-        );
-      } catch {
-      }
-    }
-    if (!pkgPath) {
-      return;
-    }
-    const pkg = await fs__default.default.readJson(pkgPath);
-    let versions = visitedPackageVersions.get(pkg.name);
-    if (versions?.has(pkg.version)) {
-      return;
-    }
-    if (!versions) {
-      versions = /* @__PURE__ */ new Set();
-      visitedPackageVersions.set(pkg.name, versions);
-    }
-    versions.add(pkg.version);
-    const depNames = [
-      ...Object.keys(pkg.dependencies ?? {}),
-      ...Object.keys(pkg.devDependencies ?? {}),
-      ...Object.keys(pkg.optionalDependencies ?? {}),
-      ...Object.keys(pkg.peerDependencies ?? {})
-    ];
-    const hasSchema = "configSchema" in pkg;
-    const hasBackstageDep = depNames.some((_) => _.startsWith("@backstage/"));
-    if (!hasSchema && !hasBackstageDep) {
-      return;
-    }
-    if (hasSchema) {
-      if (typeof pkg.configSchema === "string") {
-        const isJson = pkg.configSchema.endsWith(".json");
-        const isDts = pkg.configSchema.endsWith(".d.ts");
-        if (!isJson && !isDts) {
-          throw new Error(
-            `Config schema files must be .json or .d.ts, got ${pkg.configSchema}`
-          );
-        }
-        if (isDts) {
-          tsSchemaPaths.push(
-            path.relative(
-              currentDir,
-              path.resolve(path.dirname(pkgPath), pkg.configSchema)
-            )
-          );
-        } else {
-          const path$1 = path.resolve(path.dirname(pkgPath), pkg.configSchema);
-          const value = await fs__default.default.readJson(path$1);
-          schemas.push({
-            value,
-            path: path.relative(currentDir, path$1)
-          });
-        }
-      } else {
-        schemas.push({
-          value: pkg.configSchema,
-          path: path.relative(currentDir, pkgPath)
-        });
-      }
-    }
-    await Promise.all(
-      depNames.map(
-        (depName) => processItem({ name: depName, parentPath: pkgPath })
-      )
-    );
-  }
-  await Promise.all([
-    ...packageNames.map((name) => processItem({ name, parentPath: currentDir })),
-    ...packagePaths.map((path) => processItem({ name: path, packagePath: path }))
-  ]);
-  const tsSchemas = await compileTsSchemas(tsSchemaPaths);
-  return schemas.concat(tsSchemas);
-}
-async function compileTsSchemas(paths) {
-  if (paths.length === 0) {
-    return [];
-  }
-  const { getProgramFromFiles, buildGenerator } = await import('typescript-json-schema');
-  const program = getProgramFromFiles(paths, {
-    incremental: false,
-    isolatedModules: true,
-    lib: ["ES5"],
-    // Skipping most libs speeds processing up a lot, we just need the primitive types anyway
-    noEmit: true,
-    noResolve: true,
-    skipLibCheck: true,
-    // Skipping lib checks speeds things up
-    skipDefaultLibCheck: true,
-    strict: true,
-    typeRoots: [],
-    // Do not include any additional types
-    types: []
-  });
-  const tsSchemas = paths.map((path$1) => {
-    let value;
-    try {
-      const generator = buildGenerator(
-        program,
-        // This enables the use of these tags in TSDoc comments
-        {
-          required: true,
-          validationKeywords: ["visibility", "deepVisibility", "deprecated"]
-        },
-        [path$1.split(path.sep).join("/")]
-        // Unix paths are expected for all OSes here
-      );
-      value = generator?.getSchemaForSymbol("Config");
-      const userSymbols = new Set(generator?.getUserSymbols());
-      userSymbols.delete("Config");
-      if (userSymbols.size !== 0) {
-        const names = Array.from(userSymbols).join("', '");
-        throw new Error(
-          `Invalid configuration schema in ${path$1}, additional symbol definitions are not allowed, found '${names}'`
-        );
-      }
-      const reffedDefs = Object.keys(generator?.ReffedDefinitions ?? {});
-      if (reffedDefs.length !== 0) {
-        const lines = reffedDefs.join(`${os.EOL}  `);
-        throw new Error(
-          `Invalid configuration schema in ${path$1}, the following definitions are not supported:${os.EOL}${os.EOL}  ${lines}`
-        );
-      }
-    } catch (error) {
-      errors.assertError(error);
-      if (error.message !== "type Config not found") {
-        throw error;
-      }
-    }
-    if (!value) {
-      throw new Error(`Invalid schema in ${path$1}, missing Config export`);
-    }
-    return { path: path$1, value };
-  });
-  return tsSchemas;
-}
-
-function filterByVisibility(data, includeVisibilities, visibilityByDataPath, deepVisibilityByDataPath, deprecationByDataPath, transformFunc, withFilteredKeys, withDeprecatedKeys) {
-  const filteredKeys = new Array();
-  const deprecatedKeys = new Array();
-  function transform(jsonVal, visibilityPath, filterPath, inheritedVisibility) {
-    const visibility = visibilityByDataPath.get(visibilityPath) ?? inheritedVisibility;
-    const isVisible = includeVisibilities.includes(visibility);
-    const newInheritedVisibility = deepVisibilityByDataPath.get(visibilityPath) ?? inheritedVisibility;
-    const deprecation = deprecationByDataPath.get(visibilityPath);
-    if (deprecation) {
-      deprecatedKeys.push({ key: filterPath, description: deprecation });
-    }
-    if (typeof jsonVal !== "object") {
-      if (isVisible) {
-        if (transformFunc) {
-          return transformFunc(jsonVal, { visibility, path: filterPath });
-        }
-        return jsonVal;
-      }
-      if (withFilteredKeys) {
-        filteredKeys.push(filterPath);
-      }
-      return void 0;
-    } else if (jsonVal === null) {
-      return void 0;
-    } else if (Array.isArray(jsonVal)) {
-      const arr = new Array();
-      for (const [index, value] of jsonVal.entries()) {
-        let path = visibilityPath;
-        const hasVisibilityInIndex = visibilityByDataPath.get(
-          `${visibilityPath}/${index}`
-        );
-        if (hasVisibilityInIndex || typeof value === "object") {
-          path = `${visibilityPath}/${index}`;
-        }
-        const out = transform(
-          value,
-          path,
-          `${filterPath}[${index}]`,
-          newInheritedVisibility
-        );
-        if (out !== void 0) {
-          arr.push(out);
-        }
-      }
-      if (arr.length > 0 || isVisible) {
-        return arr;
-      }
-      return void 0;
-    }
-    const outObj = {};
-    let hasOutput = false;
-    for (const [key, value] of Object.entries(jsonVal)) {
-      if (value === void 0) {
-        continue;
-      }
-      const out = transform(
-        value,
-        `${visibilityPath}/${key}`,
-        filterPath ? `${filterPath}.${key}` : key,
-        newInheritedVisibility
-      );
-      if (out !== void 0) {
-        outObj[key] = out;
-        hasOutput = true;
-      }
-    }
-    if (hasOutput || isVisible) {
-      return outObj;
-    }
-    return void 0;
-  }
-  return {
-    filteredKeys: withFilteredKeys ? filteredKeys : void 0,
-    deprecatedKeys: withDeprecatedKeys ? deprecatedKeys : void 0,
-    data: transform(data, "", "", DEFAULT_CONFIG_VISIBILITY) ?? {}
-  };
-}
-function filterErrorsByVisibility(errors, includeVisibilities, visibilityByDataPath, visibilityBySchemaPath) {
-  if (!errors) {
-    return [];
-  }
-  if (!includeVisibilities) {
-    return errors;
-  }
-  const visibleSchemaPaths = Array.from(visibilityBySchemaPath).filter(([, v]) => includeVisibilities.includes(v)).map(([k]) => k);
-  return errors.filter((error) => {
-    if (error.keyword === "type" && ["object", "array"].includes(error.params.type)) {
-      return true;
-    }
-    if (error.keyword === "required") {
-      const trimmedPath = normalizeAjvPath(error.schemaPath).slice(
-        1,
-        -"/required".length
-      );
-      const fullPath = `${trimmedPath}/properties/${error.params.missingProperty}`;
-      if (visibleSchemaPaths.some((visiblePath) => visiblePath.startsWith(fullPath))) {
-        return true;
-      }
-    }
-    const vis = visibilityByDataPath.get(normalizeAjvPath(error.instancePath)) ?? DEFAULT_CONFIG_VISIBILITY;
-    return vis && includeVisibilities.includes(vis);
-  });
-}
-
-function errorsToError(errors) {
-  const messages = errors.map(({ instancePath, message, params }) => {
-    const paramStr = Object.entries(params).map(([name, value]) => `${name}=${value}`).join(" ");
-    return `Config ${message || ""} { ${paramStr} } at ${normalizeAjvPath(
-      instancePath
-    )}`;
-  });
-  const error = new Error(`Config validation failed, ${messages.join("; ")}`);
-  error.messages = messages;
-  return error;
-}
-async function loadConfigSchema(options) {
-  let schemas;
-  if ("dependencies" in options) {
-    schemas = await collectConfigSchemas(
-      options.dependencies,
-      options.packagePaths ?? []
-    );
-  } else {
-    const { serialized } = options;
-    if (serialized?.backstageConfigSchemaVersion !== 1) {
-      throw new Error(
-        "Serialized configuration schema is invalid or has an invalid version number"
-      );
-    }
-    schemas = serialized.schemas;
-  }
-  const validate = compileConfigSchemas(schemas, {
-    noUndeclaredProperties: options.noUndeclaredProperties
-  });
-  return {
-    process(configs, {
-      visibility,
-      valueTransform,
-      withFilteredKeys,
-      withDeprecatedKeys,
-      ignoreSchemaErrors
-    } = {}) {
-      const result = validate(configs);
-      if (!ignoreSchemaErrors) {
-        const visibleErrors = filterErrorsByVisibility(
-          result.errors,
-          visibility,
-          result.visibilityByDataPath,
-          result.visibilityBySchemaPath
-        );
-        if (visibleErrors.length > 0) {
-          throw errorsToError(visibleErrors);
-        }
-      }
-      let processedConfigs = configs;
-      if (visibility) {
-        processedConfigs = processedConfigs.map(({ data, context }) => ({
-          context,
-          ...filterByVisibility(
-            data,
-            visibility,
-            result.visibilityByDataPath,
-            result.deepVisibilityByDataPath,
-            result.deprecationByDataPath,
-            valueTransform,
-            withFilteredKeys,
-            withDeprecatedKeys
-          )
-        }));
-      } else if (valueTransform) {
-        processedConfigs = processedConfigs.map(({ data, context }) => ({
-          context,
-          ...filterByVisibility(
-            data,
-            Array.from(CONFIG_VISIBILITIES),
-            result.visibilityByDataPath,
-            result.deepVisibilityByDataPath,
-            result.deprecationByDataPath,
-            valueTransform,
-            withFilteredKeys,
-            withDeprecatedKeys
-          )
-        }));
-      }
-      return processedConfigs;
-    },
-    serialize() {
-      return {
-        schemas,
-        backstageConfigSchemaVersion: 1
-      };
-    }
-  };
-}
-
-class EnvConfigSource {
-  constructor(env) {
-    this.env = env;
-  }
-  /**
-   * Creates a new config source that reads from the environment.
-   *
-   * @param options - Options for the config source.
-   * @returns A new config source that reads from the environment.
-   */
-  static create(options) {
-    return new EnvConfigSource(options?.env ?? process.env);
-  }
-  async *readConfigData() {
-    const configs = readEnvConfig(this.env);
-    yield { configs };
-    return;
-  }
-  toString() {
-    const keys = Object.keys(this.env).filter(
-      (key) => key.startsWith("APP_CONFIG_")
-    );
-    return `EnvConfigSource{count=${keys.length}}`;
-  }
-}
-const ENV_PREFIX = "APP_CONFIG_";
-const CONFIG_KEY_PART_PATTERN = /^[a-z][a-z0-9]*(?:[-_][a-z][a-z0-9]*)*$/i;
-function readEnvConfig(env) {
-  let data = void 0;
-  for (const [name, value] of Object.entries(env)) {
-    if (!value) {
-      continue;
-    }
-    if (name.startsWith(ENV_PREFIX)) {
-      const key = name.replace(ENV_PREFIX, "");
-      const keyParts = key.split("_");
-      let obj = data = data ?? {};
-      for (const [index, part] of keyParts.entries()) {
-        if (!CONFIG_KEY_PART_PATTERN.test(part)) {
-          throw new TypeError(`Invalid env config key '${key}'`);
-        }
-        if (index < keyParts.length - 1) {
-          obj = obj[part] = obj[part] ?? {};
-          if (typeof obj !== "object" || Array.isArray(obj)) {
-            const subKey = keyParts.slice(0, index + 1).join("_");
-            throw new TypeError(
-              `Could not nest config for key '${key}' under existing value '${subKey}'`
-            );
-          }
-        } else {
-          if (part in obj) {
-            throw new TypeError(
-              `Refusing to override existing config at key '${key}'`
-            );
-          }
-          try {
-            const [, parsedValue] = safeJsonParse(value);
-            if (parsedValue === null) {
-              throw new Error("value may not be null");
-            }
-            obj[part] = parsedValue;
-          } catch (error) {
-            throw new TypeError(
-              `Failed to parse JSON-serialized config value for key '${key}', ${error}`
-            );
-          }
-        }
-      }
-    }
-  }
-  return data ? [{ data, context: "env" }] : [];
-}
-function safeJsonParse(str) {
-  try {
-    return [null, JSON.parse(str)];
-  } catch (err) {
-    errors.assertError(err);
-    return [err, str];
-  }
-}
-
-function isObject(obj) {
-  if (typeof obj !== "object") {
-    return false;
-  } else if (Array.isArray(obj)) {
-    return false;
-  }
-  return obj !== null;
-}
-
-function createSubstitutionTransform(env) {
-  return async (input) => {
-    if (typeof input !== "string") {
-      return { applied: false };
-    }
-    const parts = input.split(/(\$?\$\{[^{}]*\})/);
-    for (let i = 1; i < parts.length; i += 2) {
-      const part = parts[i];
-      if (part.startsWith("$$")) {
-        parts[i] = part.slice(1);
-      } else {
-        const indexOfFallbackSeparator = part.indexOf(":-");
-        if (indexOfFallbackSeparator > -1) {
-          const envVarValue = await env(
-            part.slice(2, indexOfFallbackSeparator).trim()
-          );
-          const fallbackValue = part.slice(indexOfFallbackSeparator + ":-".length, -1).trim();
-          parts[i] = envVarValue || fallbackValue || void 0;
-        } else {
-          parts[i] = await env(part.slice(2, -1).trim());
-        }
-      }
-    }
-    if (parts.some((part) => part === void 0)) {
-      return { applied: true, value: void 0 };
-    }
-    return { applied: true, value: parts.join("") };
-  };
-}
-
-const includeFileParser = {
-  ".json": async (content) => JSON.parse(content),
-  ".yaml": async (content) => yaml__default.default.parse(content),
-  ".yml": async (content) => yaml__default.default.parse(content)
-};
-function createIncludeTransform(env, readFile, substitute) {
-  return async (input, context) => {
-    const { dir } = context;
-    if (!dir) {
-      throw new Error("Include transform requires a base directory");
-    }
-    if (!isObject(input)) {
-      return { applied: false };
-    }
-    const [includeKey] = Object.keys(input).filter((key) => key.startsWith("$"));
-    if (includeKey) {
-      if (Object.keys(input).length !== 1) {
-        throw new Error(
-          `include key ${includeKey} should not have adjacent keys`
-        );
-      }
-    } else {
-      return { applied: false };
-    }
-    const rawIncludedValue = input[includeKey];
-    if (typeof rawIncludedValue !== "string") {
-      throw new Error(`${includeKey} include value is not a string`);
-    }
-    const substituteResults = await substitute(rawIncludedValue, { dir });
-    const includeValue = substituteResults.applied ? substituteResults.value : rawIncludedValue;
-    if (includeValue === void 0 || typeof includeValue !== "string") {
-      throw new Error(`${includeKey} substitution value was undefined`);
-    }
-    switch (includeKey) {
-      case "$file":
-        try {
-          const value = await readFile(path.resolve(dir, includeValue));
-          return { applied: true, value: value.trimEnd() };
-        } catch (error) {
-          throw new Error(`failed to read file ${includeValue}, ${error}`);
-        }
-      case "$env":
-        try {
-          return { applied: true, value: await env(includeValue) };
-        } catch (error) {
-          throw new Error(`failed to read env ${includeValue}, ${error}`);
-        }
-      case "$include": {
-        const [filePath, dataPath] = includeValue.split(/#(.*)/);
-        const ext = path.extname(filePath);
-        const parser = includeFileParser[ext];
-        if (!parser) {
-          throw new Error(
-            `no configuration parser available for included file ${filePath}`
-          );
-        }
-        const path$1 = path.resolve(dir, filePath);
-        const content = await readFile(path$1);
-        const newDir = path.dirname(path$1);
-        const parts = dataPath ? dataPath.split(".") : [];
-        let value;
-        try {
-          value = await parser(content);
-        } catch (error) {
-          throw new Error(
-            `failed to parse included file ${filePath}, ${error}`
-          );
-        }
-        for (const [index, part] of parts.entries()) {
-          if (!isObject(value)) {
-            const errPath = parts.slice(0, index).join(".");
-            throw new Error(
-              `value at '${errPath}' in included file ${filePath} is not an object`
-            );
-          }
-          value = value[part];
-        }
-        if (typeof value === "string") {
-          const substituted = await substitute(value, { dir: newDir });
-          if (substituted.applied) {
-            value = substituted.value;
-          }
-        }
-        return {
-          applied: true,
-          value,
-          newDir: newDir !== dir ? newDir : void 0
-        };
-      }
-      default:
-        throw new Error(`unknown include ${includeKey}`);
-    }
-  };
-}
-
-async function applyConfigTransforms(input, context, transforms) {
-  async function transform(inputObj, path, baseDir) {
-    let obj = inputObj;
-    let dir = baseDir;
-    for (const tf of transforms) {
-      try {
-        const result = await tf(inputObj, { dir });
-        if (result.applied) {
-          if (result.value === void 0) {
-            return void 0;
-          }
-          obj = result.value;
-          dir = result?.newDir ?? dir;
-          break;
-        }
-      } catch (error) {
-        errors.assertError(error);
-        throw new Error(`error at ${path}, ${error.message}`);
-      }
-    }
-    if (typeof obj !== "object") {
-      return obj;
-    } else if (obj === null) {
-      return null;
-    } else if (Array.isArray(obj)) {
-      const arr = new Array();
-      for (const [index, value] of obj.entries()) {
-        const out2 = await transform(value, `${path}[${index}]`, dir);
-        if (out2 !== void 0) {
-          arr.push(out2);
-        }
-      }
-      return arr;
-    }
-    const out = {};
-    for (const [key, value] of Object.entries(obj)) {
-      if (value !== void 0) {
-        const result = await transform(value, `${path}.${key}`, dir);
-        if (result !== void 0) {
-          out[key] = result;
-        }
-      }
-    }
-    return out;
-  }
-  const finalData = await transform(input, "", context?.dir);
-  if (!isObject(finalData)) {
-    throw new TypeError("expected object at config root");
-  }
-  return finalData;
-}
-function createConfigTransformer(options) {
-  const {
-    substitutionFunc = async (name) => process.env[name]?.trim(),
-    readFile
-  } = options;
-  const substitutionTransform = createSubstitutionTransform(substitutionFunc);
-  const transforms = [substitutionTransform];
-  if (readFile) {
-    const includeTransform = createIncludeTransform(
-      substitutionFunc,
-      readFile,
-      substitutionTransform
-    );
-    transforms.push(includeTransform);
-  }
-  return async (input, ctx) => applyConfigTransforms(input, ctx ?? {}, transforms);
-}
-
-function simpleDefer() {
-  let resolve;
-  const promise = new Promise((_resolve) => {
-    resolve = _resolve;
-  });
-  return { promise, resolve };
-}
-async function waitOrAbort(promise, signal) {
-  const signals = [signal].flat().filter((x) => !!x);
-  return new Promise((resolve, reject) => {
-    if (signals.some((s) => s.aborted)) {
-      resolve([false]);
-    }
-    const onAbort = () => {
-      resolve([false]);
-    };
-    promise.then(
-      (value) => {
-        resolve([true, value]);
-        signals.forEach((s) => s.removeEventListener("abort", onAbort));
-      },
-      (error) => {
-        reject(error);
-        signals.forEach((s) => s.removeEventListener("abort", onAbort));
-      }
-    );
-    signals.forEach((s) => s.addEventListener("abort", onAbort));
-  });
-}
-const parseYamlContent = async ({ contents }) => {
-  const parsed = yaml__default.default.parse(contents);
-  return { result: parsed === null ? void 0 : parsed };
-};
-
-async function readFile(path) {
-  try {
-    const content = await fs__default.default.readFile(path, "utf8");
-    if (content === "") {
-      await new Promise((resolve) => setTimeout(resolve, 10));
-      return await fs__default.default.readFile(path, "utf8");
-    }
-    return content;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return void 0;
-    }
-    throw error;
-  }
-}
-class FileConfigSource {
-  /**
-   * Creates a new config source that loads configuration from the given path.
-   *
-   * @remarks
-   *
-   * The source will watch the file for changes, as well as any referenced files.
-   *
-   * @param options - Options for the config source.
-   * @returns A new config source that loads from the given path.
-   */
-  static create(options) {
-    if (!path.isAbsolute(options.path)) {
-      throw new Error(`Config load path is not absolute: "${options.path}"`);
-    }
-    return new FileConfigSource(options);
-  }
-  #path;
-  #substitutionFunc;
-  #watch;
-  #parser;
-  constructor(options) {
-    this.#path = options.path;
-    this.#substitutionFunc = options.substitutionFunc;
-    this.#watch = options.watch ?? true;
-    this.#parser = options.parser ?? parseYamlContent;
-  }
-  // Work is duplicated across each read, in practice that should not
-  // have any impact since there won't be multiple consumers. If that
-  // changes it might be worth refactoring this to avoid duplicate work.
-  async *readConfigData(options) {
-    const signal = options?.signal;
-    const configFileName = path.basename(this.#path);
-    let watchedPaths = null;
-    let watcher = null;
-    if (this.#watch) {
-      watchedPaths = new Array();
-      watcher = chokidar__default.default.watch(this.#path, {
-        usePolling: process.env.NODE_ENV === "test"
-      });
-    }
-    const dir = path.dirname(this.#path);
-    const transformer = createConfigTransformer({
-      substitutionFunc: this.#substitutionFunc,
-      readFile: async (path$1) => {
-        const fullPath = path.resolve(dir, path$1);
-        if (watcher && watchedPaths) {
-          watcher.add(fullPath);
-          watchedPaths.push(fullPath);
-        }
-        const data = await readFile(fullPath);
-        if (data === void 0) {
-          throw new errors.NotFoundError(
-            `failed to include "${fullPath}", file does not exist`
-          );
-        }
-        return data;
-      }
-    });
-    const readConfigFile = async () => {
-      if (watcher && watchedPaths) {
-        watcher.unwatch(watchedPaths);
-        watchedPaths.length = 0;
-        watcher.add(this.#path);
-        watchedPaths.push(this.#path);
-      }
-      const contents = await readFile(this.#path);
-      if (contents === void 0) {
-        throw new errors.NotFoundError(`Config file "${this.#path}" does not exist`);
-      }
-      const { result: parsed } = await this.#parser({ contents });
-      if (parsed === void 0) {
-        return [];
-      }
-      try {
-        const data = await transformer(parsed, { dir });
-        return [{ data, context: configFileName, path: this.#path }];
-      } catch (error) {
-        throw new Error(
-          `Failed to read config file at "${this.#path}", ${error.message}`
-        );
-      }
-    };
-    const onAbort = () => {
-      signal?.removeEventListener("abort", onAbort);
-      if (watcher) watcher.close();
-    };
-    signal?.addEventListener("abort", onAbort);
-    yield { configs: await readConfigFile() };
-    if (watcher) {
-      for (; ; ) {
-        const event = await this.#waitForEvent(watcher, signal);
-        if (event === "abort") {
-          return;
-        }
-        yield { configs: await readConfigFile() };
-      }
-    }
-  }
-  toString() {
-    return `FileConfigSource{path="${this.#path}"}`;
-  }
-  #waitForEvent(watcher, signal) {
-    return new Promise((resolve) => {
-      function onChange() {
-        resolve("change");
-        onDone();
-      }
-      function onAbort() {
-        resolve("abort");
-        onDone();
-      }
-      function onDone() {
-        watcher.removeListener("change", onChange);
-        signal?.removeEventListener("abort", onAbort);
-      }
-      watcher.addListener("change", onChange);
-      signal?.addEventListener("abort", onAbort);
-    });
-  }
-}
-
-const sourcesSymbol = Symbol.for(
-  "@backstage/config-loader#MergedConfigSource.sources"
-);
-class MergedConfigSource {
-  constructor(sources) {
-    this.sources = sources;
-    this[sourcesSymbol] = this.sources;
-  }
-  // An optimization to flatten nested merged sources to avid unnecessary microtasks
-  static #flattenSources(sources) {
-    return sources.flatMap((source) => {
-      if (sourcesSymbol in source && Array.isArray(source[sourcesSymbol])) {
-        return this.#flattenSources(
-          source[sourcesSymbol]
-        );
-      }
-      return source;
-    });
-  }
-  static from(sources) {
-    return new MergedConfigSource(this.#flattenSources(sources));
-  }
-  [sourcesSymbol];
-  async *readConfigData(options) {
-    const its = this.sources.map((source) => source.readConfigData(options));
-    const initialResults = await Promise.all(its.map((it) => it.next()));
-    const configs = initialResults.map((result, i) => {
-      if (result.done) {
-        throw new Error(
-          `Config source ${String(this.sources[i])} returned no data`
-        );
-      }
-      return result.value.configs;
-    });
-    yield { configs: configs.flat(1) };
-    const results = its.map((it, i) => nextWithIndex(it, i));
-    while (results.some(Boolean)) {
-      try {
-        const [i, result] = await Promise.race(results.filter(Boolean));
-        if (result.done) {
-          results[i] = void 0;
-        } else {
-          results[i] = nextWithIndex(its[i], i);
-          configs[i] = result.value.configs;
-          yield { configs: configs.flat(1) };
-        }
-      } catch (error) {
-        const source = this.sources[error.index];
-        if (source) {
-          throw new Error(`Config source ${String(source)} failed: ${error}`);
-        }
-        throw error;
-      }
-    }
-  }
-  toString() {
-    return `MergedConfigSource{${this.sources.map(String).join(", ")}}`;
-  }
-}
-function nextWithIndex(iterator, index) {
-  return iterator.next().then(
-    (r) => [index, r],
-    (e) => {
-      throw Object.assign(e, { index });
-    }
-  );
-}
-
-const DEFAULT_RELOAD_INTERVAL = { seconds: 60 };
-class RemoteConfigSource {
-  /**
-   * Creates a new {@link RemoteConfigSource}.
-   *
-   * @param options - Options for the source.
-   * @returns A new remote config source.
-   */
-  static create(options) {
-    try {
-      new URL(options.url);
-    } catch (error) {
-      throw new Error(
-        `Invalid URL provided to remote config source, '${options.url}', ${error}`
-      );
-    }
-    return new RemoteConfigSource(options);
-  }
-  #url;
-  #reloadIntervalMs;
-  #transformer;
-  #parser;
-  constructor(options) {
-    this.#url = options.url;
-    this.#reloadIntervalMs = types.durationToMilliseconds(
-      options.reloadInterval ?? DEFAULT_RELOAD_INTERVAL
-    );
-    this.#transformer = createConfigTransformer({
-      substitutionFunc: options.substitutionFunc
-    });
-    this.#parser = options.parser ?? parseYamlContent;
-  }
-  async *readConfigData(options) {
-    let data = await this.#load();
-    yield { configs: [{ data, context: this.#url }] };
-    for (; ; ) {
-      await this.#wait(options?.signal);
-      if (options?.signal?.aborted) {
-        return;
-      }
-      try {
-        const newData = await this.#load(options?.signal);
-        if (newData && !isEqual__default.default(data, newData)) {
-          data = newData;
-          yield { configs: [{ data, context: this.#url }] };
-        }
-      } catch (error) {
-        if (error.name !== "AbortError") {
-          console.error(`Failed to read config from ${this.#url}, ${error}`);
-        }
-      }
-    }
-  }
-  toString() {
-    return `RemoteConfigSource{path="${this.#url}"}`;
-  }
-  async #load(signal) {
-    const res = await fetch__default.default(this.#url, {
-      signal
-    });
-    if (!res.ok) {
-      throw await errors.ResponseError.fromResponse(res);
-    }
-    const contents = await res.text();
-    const { result: rawData } = await this.#parser({ contents });
-    if (rawData === void 0) {
-      throw new Error("configuration data is null");
-    }
-    const data = await this.#transformer(rawData);
-    if (typeof data !== "object") {
-      throw new Error("configuration data is not an object");
-    } else if (Array.isArray(data)) {
-      throw new Error(
-        "configuration data is an array, expected an object instead"
-      );
-    }
-    return data;
-  }
-  async #wait(signal) {
-    return new Promise((resolve) => {
-      const timeoutId = setTimeout(onDone, this.#reloadIntervalMs);
-      signal?.addEventListener("abort", onDone);
-      function onDone() {
-        clearTimeout(timeoutId);
-        signal?.removeEventListener("abort", onDone);
-        resolve();
-      }
-    });
-  }
-}
-
-class ObservableConfigProxy {
-  constructor(parent, parentKey, abortController) {
-    this.parent = parent;
-    this.parentKey = parentKey;
-    this.abortController = abortController;
-    if (parent && !parentKey) {
-      throw new Error("parentKey is required if parent is set");
-    }
-  }
-  config = new config.ConfigReader({});
-  subscribers = [];
-  static create(abortController) {
-    return new ObservableConfigProxy(void 0, void 0, abortController);
-  }
-  setConfig(config) {
-    if (this.parent) {
-      throw new Error("immutable");
-    }
-    const changed = !isEqual__default.default(this.config.get(), config.get());
-    this.config = config;
-    if (changed) {
-      for (const subscriber of this.subscribers) {
-        try {
-          subscriber();
-        } catch (error) {
-          console.error(`Config subscriber threw error, ${error}`);
-        }
-      }
-    }
-  }
-  close() {
-    if (!this.abortController) {
-      throw new Error("Only the root config can be closed");
-    }
-    this.abortController.abort();
-  }
-  subscribe(onChange) {
-    if (this.parent) {
-      return this.parent.subscribe(onChange);
-    }
-    this.subscribers.push(onChange);
-    return {
-      unsubscribe: () => {
-        const index = this.subscribers.indexOf(onChange);
-        if (index >= 0) {
-          this.subscribers.splice(index, 1);
-        }
-      }
-    };
-  }
-  select(required) {
-    if (this.parent && this.parentKey) {
-      if (required) {
-        return this.parent.select(true).getConfig(this.parentKey);
-      }
-      return this.parent.select(false)?.getOptionalConfig(this.parentKey);
-    }
-    return this.config;
-  }
-  has(key) {
-    return this.select(false)?.has(key) ?? false;
-  }
-  keys() {
-    return this.select(false)?.keys() ?? [];
-  }
-  get(key) {
-    return this.select(true).get(key);
-  }
-  getOptional(key) {
-    return this.select(false)?.getOptional(key);
-  }
-  getConfig(key) {
-    return new ObservableConfigProxy(this, key);
-  }
-  getOptionalConfig(key) {
-    if (this.select(false)?.has(key)) {
-      return new ObservableConfigProxy(this, key);
-    }
-    return void 0;
-  }
-  getConfigArray(key) {
-    return this.select(true).getConfigArray(key);
-  }
-  getOptionalConfigArray(key) {
-    return this.select(false)?.getOptionalConfigArray(key);
-  }
-  getNumber(key) {
-    return this.select(true).getNumber(key);
-  }
-  getOptionalNumber(key) {
-    return this.select(false)?.getOptionalNumber(key);
-  }
-  getBoolean(key) {
-    return this.select(true).getBoolean(key);
-  }
-  getOptionalBoolean(key) {
-    return this.select(false)?.getOptionalBoolean(key);
-  }
-  getString(key) {
-    return this.select(true).getString(key);
-  }
-  getOptionalString(key) {
-    return this.select(false)?.getOptionalString(key);
-  }
-  getStringArray(key) {
-    return this.select(true).getStringArray(key);
-  }
-  getOptionalStringArray(key) {
-    return this.select(false)?.getOptionalStringArray(key);
-  }
-}
-
-class ConfigSources {
-  /**
-   * Parses command line arguments and returns the config targets.
-   *
-   * @param argv - The command line arguments to parse. Defaults to `process.argv`
-   * @returns A list of config targets
-   */
-  static parseArgs(argv = process.argv) {
-    const args = [parseArgs__default.default(argv).config].flat().filter(Boolean);
-    return args.map((target) => {
-      try {
-        const url = new URL(target);
-        if (!url.host) {
-          return { type: "path", target };
-        }
-        return { type: "url", target };
-      } catch {
-        return { type: "path", target };
-      }
-    });
-  }
-  /**
-   * Creates the default config sources for the provided targets.
-   *
-   * @remarks
-   *
-   * This will create {@link FileConfigSource}s and {@link RemoteConfigSource}s
-   * for the provided targets, and merge them together to a single source.
-   * If no targets are provided it will fall back to `app-config.yaml` and
-   * `app-config.local.yaml`.
-   *
-   * URL targets are only supported if the `remote` option is provided.
-   *
-   * @param options - Options
-   * @returns A config source for the provided targets
-   */
-  static defaultForTargets(options) {
-    const rootDir = options.rootDir ?? cliCommon.findPaths(process.cwd()).targetRoot;
-    const argSources = options.targets.map((arg) => {
-      if (arg.type === "url") {
-        if (!options.remote) {
-          throw new Error(
-            `Config argument "${arg.target}" looks like a URL but remote configuration is not enabled. Enable it by passing the \`remote\` option`
-          );
-        }
-        return RemoteConfigSource.create({
-          url: arg.target,
-          substitutionFunc: options.substitutionFunc,
-          reloadInterval: options.remote.reloadInterval
-        });
-      }
-      return FileConfigSource.create({
-        watch: options.watch,
-        path: path.resolve(arg.target),
-        substitutionFunc: options.substitutionFunc
-      });
-    });
-    if (argSources.length === 0) {
-      const defaultPath = path.resolve(rootDir, "app-config.yaml");
-      const localPath = path.resolve(rootDir, "app-config.local.yaml");
-      const alwaysIncludeDefaultConfigSource = !options.allowMissingDefaultConfig;
-      if (alwaysIncludeDefaultConfigSource || fs__default.default.pathExistsSync(defaultPath)) {
-        argSources.push(
-          FileConfigSource.create({
-            watch: options.watch,
-            path: defaultPath,
-            substitutionFunc: options.substitutionFunc
-          })
-        );
-      }
-      if (fs__default.default.pathExistsSync(localPath)) {
-        argSources.push(
-          FileConfigSource.create({
-            watch: options.watch,
-            path: localPath,
-            substitutionFunc: options.substitutionFunc
-          })
-        );
-      }
-    }
-    return this.merge(argSources);
-  }
-  /**
-   * Creates the default config source for Backstage.
-   *
-   * @remarks
-   *
-   * This will read from `app-config.yaml` and `app-config.local.yaml` by
-   * default, as well as environment variables prefixed with `APP_CONFIG_`.
-   * If `--config <path|url>` command line arguments are passed, these will
-   * override the default configuration file paths. URLs are only supported
-   * if the `remote` option is provided.
-   *
-   * @param options - Options
-   * @returns The default Backstage config source
-   */
-  static default(options) {
-    const argSource = this.defaultForTargets({
-      ...options,
-      targets: this.parseArgs(options.argv)
-    });
-    const envSource = EnvConfigSource.create({
-      env: options.env
-    });
-    return this.merge([argSource, envSource]);
-  }
-  /**
-   * Merges multiple config sources into a single source that reads from all
-   * sources and concatenates the result.
-   *
-   * @param sources - The config sources to merge
-   * @returns A single config source that concatenates the data from the given sources
-   */
-  static merge(sources) {
-    return MergedConfigSource.from(sources);
-  }
-  /**
-   * Creates an observable {@link @backstage/config#Config} implementation from a {@link ConfigSource}.
-   *
-   * @remarks
-   *
-   * If you only want to read the config once you can close the returned config immediately.
-   *
-   * @example
-   *
-   * ```ts
-   * const sources = ConfigSources.default(...)
-   * const config = await ConfigSources.toConfig(source)
-   * config.close()
-   * const example = config.getString(...)
-   * ```
-   *
-   * @param source - The config source to read from
-   * @returns A promise that resolves to a closable config
-   */
-  static toConfig(source) {
-    return new Promise(async (resolve, reject) => {
-      let config$1 = void 0;
-      try {
-        const abortController = new AbortController();
-        for await (const { configs } of source.readConfigData({
-          signal: abortController.signal
-        })) {
-          if (config$1) {
-            config$1.setConfig(config.ConfigReader.fromConfigs(configs));
-          } else {
-            config$1 = ObservableConfigProxy.create(abortController);
-            config$1.setConfig(config.ConfigReader.fromConfigs(configs));
-            resolve(config$1);
-          }
-        }
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-}
-
-class MutableConfigSource {
-  /**
-   * Creates a new mutable config source.
-   *
-   * @param options - Options for the config source.
-   * @returns A new mutable config source.
-   */
-  static create(options) {
-    return new MutableConfigSource(
-      options?.context ?? "mutable-config",
-      options?.data
-    );
-  }
-  #currentData;
-  #deferred;
-  #context;
-  #abortController = new AbortController();
-  constructor(context, initialData) {
-    this.#currentData = initialData;
-    this.#context = context;
-    this.#deferred = simpleDefer();
-  }
-  async *readConfigData(options) {
-    let deferredPromise = this.#deferred.promise;
-    if (this.#currentData !== void 0) {
-      yield { configs: [{ data: this.#currentData, context: this.#context }] };
-    }
-    for (; ; ) {
-      const [ok] = await waitOrAbort(deferredPromise, [
-        options?.signal,
-        this.#abortController.signal
-      ]);
-      if (!ok) {
-        return;
-      }
-      deferredPromise = this.#deferred.promise;
-      if (this.#currentData !== void 0) {
-        yield {
-          configs: [{ data: this.#currentData, context: this.#context }]
-        };
-      }
-    }
-  }
-  /**
-   * Set the data of the config source.
-   *
-   * @param data - The new data to set
-   */
-  setData(data) {
-    if (!this.#abortController.signal.aborted) {
-      this.#currentData = data;
-      const oldDeferred = this.#deferred;
-      this.#deferred = simpleDefer();
-      oldDeferred.resolve();
-    }
-  }
-  /**
-   * Close the config source, preventing any further updates.
-   */
-  close() {
-    this.#currentData = void 0;
-    this.#abortController.abort();
-  }
-  toString() {
-    return `MutableConfigSource{}`;
-  }
-}
-
-class StaticObservableConfigSource {
-  constructor(data, context) {
-    this.data = data;
-    this.context = context;
-  }
-  async *readConfigData(options) {
-    const queue = new Array();
-    let deferred = simpleDefer();
-    const sub = this.data.subscribe({
-      next(value) {
-        queue.push(value);
-        deferred.resolve();
-        deferred = simpleDefer();
-      },
-      complete() {
-        deferred.resolve();
-      }
-    });
-    const signal = options?.signal;
-    if (signal) {
-      const onAbort = () => {
-        sub.unsubscribe();
-        queue.length = 0;
-        deferred.resolve();
-        signal.removeEventListener("abort", onAbort);
-      };
-      signal.addEventListener("abort", onAbort);
-    }
-    for (; ; ) {
-      await deferred.promise;
-      if (queue.length === 0) {
-        return;
-      }
-      while (queue.length > 0) {
-        yield { configs: [{ data: queue.shift(), context: this.context }] };
-      }
-    }
-  }
-}
-function isObservable(value) {
-  return "subscribe" in value && typeof value.subscribe === "function";
-}
-function isAsyncIterable(value) {
-  return Symbol.asyncIterator in value;
-}
-class StaticConfigSource {
-  constructor(promise, context) {
-    this.promise = promise;
-    this.context = context;
-  }
-  /**
-   * Creates a new {@link StaticConfigSource}.
-   *
-   * @param options - Options for the config source
-   * @returns A new static config source
-   */
-  static create(options) {
-    const { data, context = "static-config" } = options;
-    if (!data) {
-      return {
-        async *readConfigData() {
-          yield { configs: [] };
-          return;
-        }
-      };
-    }
-    if (isObservable(data)) {
-      return new StaticObservableConfigSource(data, context);
-    }
-    if (isAsyncIterable(data)) {
-      return {
-        async *readConfigData() {
-          for await (const value of data) {
-            yield { configs: [{ data: value, context }] };
-          }
-        }
-      };
-    }
-    return new StaticConfigSource(data, context);
-  }
-  async *readConfigData() {
-    yield { configs: [{ data: await this.promise, context: this.context }] };
-    return;
-  }
-  toString() {
-    return `StaticConfigSource{}`;
-  }
-}
-
-async function loadConfig(options) {
-  const source = ConfigSources.default({
-    substitutionFunc: options.experimentalEnvFunc,
-    remote: options.remote && {
-      reloadInterval: { seconds: options.remote.reloadIntervalSeconds }
-    },
-    watch: Boolean(options.watch),
-    rootDir: options.configRoot,
-    argv: options.configTargets.flatMap((t) => [
-      "--config",
-      "url" in t ? t.url : t.path
-    ])
-  });
-  return new Promise((resolve, reject) => {
-    async function loadConfigReaderLoop() {
-      let loaded = false;
-      try {
-        const abortController = new AbortController();
-        options.watch?.stopSignal?.then(() => abortController.abort());
-        for await (const { configs } of source.readConfigData({
-          signal: abortController.signal
-        })) {
-          if (loaded) {
-            options.watch?.onChange(configs);
-          } else {
-            resolve({ appConfigs: configs });
-            loaded = true;
-            if (options.watch) {
-              options.watch.stopSignal?.then(() => abortController.abort());
-            } else {
-              abortController.abort();
-            }
-          }
-        }
-      } catch (error) {
-        if (loaded) {
-          console.error(`Failed to reload configuration, ${error}`);
-        } else {
-          reject(error);
-        }
-      }
-    }
-    loadConfigReaderLoop();
-  });
-}
-
-exports.ConfigSources = ConfigSources;
-exports.EnvConfigSource = EnvConfigSource;
-exports.FileConfigSource = FileConfigSource;
-exports.MutableConfigSource = MutableConfigSource;
-exports.RemoteConfigSource = RemoteConfigSource;
-exports.StaticConfigSource = StaticConfigSource;
-exports.loadConfig = loadConfig;
-exports.loadConfigSchema = loadConfigSchema;
-exports.mergeConfigSchemas = mergeConfigSchemas;
-exports.readEnvConfig = readEnvConfig;
+var compile = require('./schema/compile.cjs.js');
+var load = require('./schema/load.cjs.js');
+var loader = require('./loader.cjs.js');
+var ConfigSources = require('./sources/ConfigSources.cjs.js');
+var EnvConfigSource = require('./sources/EnvConfigSource.cjs.js');
+var FileConfigSource = require('./sources/FileConfigSource.cjs.js');
+var MutableConfigSource = require('./sources/MutableConfigSource.cjs.js');
+var RemoteConfigSource = require('./sources/RemoteConfigSource.cjs.js');
+var StaticConfigSource = require('./sources/StaticConfigSource.cjs.js');
+
+
+
+exports.mergeConfigSchemas = compile.mergeConfigSchemas;
+exports.loadConfigSchema = load.loadConfigSchema;
+exports.loadConfig = loader.loadConfig;
+exports.ConfigSources = ConfigSources.ConfigSources;
+exports.EnvConfigSource = EnvConfigSource.EnvConfigSource;
+exports.readEnvConfig = EnvConfigSource.readEnvConfig;
+exports.FileConfigSource = FileConfigSource.FileConfigSource;
+exports.MutableConfigSource = MutableConfigSource.MutableConfigSource;
+exports.RemoteConfigSource = RemoteConfigSource.RemoteConfigSource;
+exports.StaticConfigSource = StaticConfigSource.StaticConfigSource;
 //# sourceMappingURL=index.cjs.js.map