@backstage/config-loader 1.2.0 → 1.3.0

package/dist/index.cjs.js

@@ -2,16 +2,19 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var errors = require('@backstage/errors');
-var yaml = require('yaml');
-var path = require('path');
 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 path = require('path');
+var errors = require('@backstage/errors');
+var parseArgs = require('minimist');
 var chokidar = require('chokidar');
+var yaml = require('yaml');
+var isEqual = require('lodash/isEqual');
 var fetch = require('node-fetch');
+var cliCommon = require('@backstage/cli-common');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -33,243 +36,20 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var yaml__default = /*#__PURE__*/_interopDefaultLegacy(yaml);
 var Ajv__default = /*#__PURE__*/_interopDefaultLegacy(Ajv);
 var mergeAllOf__default = /*#__PURE__*/_interopDefaultLegacy(mergeAllOf);
 var traverse__default = /*#__PURE__*/_interopDefaultLegacy(traverse);
 var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var parseArgs__default = /*#__PURE__*/_interopDefaultLegacy(parseArgs);
 var chokidar__default = /*#__PURE__*/_interopDefaultLegacy(chokidar);
+var yaml__default = /*#__PURE__*/_interopDefaultLegacy(yaml);
+var isEqual__default = /*#__PURE__*/_interopDefaultLegacy(isEqual);
 var fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
 
-const ENV_PREFIX = "APP_CONFIG_";
-const CONFIG_KEY_PART_PATTERN = /^[a-z][a-z0-9]*(?:[-_][a-z][a-z0-9]*)*$/i;
-function readEnvConfig(env) {
-  var _a;
-  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 != null ? 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] = (_a = obj[part]) != null ? _a : {};
-          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;
-}
-
-async function applyConfigTransforms(initialDir, input, transforms) {
-  async function transform(inputObj, path, baseDir) {
-    var _a;
-    let obj = inputObj;
-    let dir = baseDir;
-    for (const tf of transforms) {
-      try {
-        const result = await tf(inputObj, baseDir);
-        if (result.applied) {
-          if (result.value === void 0) {
-            return void 0;
-          }
-          obj = result.value;
-          dir = (_a = result.newBaseDir) != null ? _a : 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 void 0;
-    } 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, "", initialDir);
-  if (!isObject(finalData)) {
-    throw new TypeError("expected object at config root");
-  }
-  return finalData;
-}
-
-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, baseDir) => {
-    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, baseDir);
-    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(baseDir, 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(baseDir, filePath);
-        const content = await readFile(path$1);
-        const newBaseDir = 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];
-        }
-        return {
-          applied: true,
-          value,
-          newBaseDir: newBaseDir !== baseDir ? newBaseDir : void 0
-        };
-      }
-      default:
-        throw new Error(`unknown include ${includeKey}`);
-    }
-  };
-}
-
-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 {
-        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 CONFIG_VISIBILITIES = ["frontend", "backend", "secret"];
 const DEFAULT_CONFIG_VISIBILITY = "backend";
 
-function compileConfigSchemas(schemas) {
+function compileConfigSchemas(schemas, options) {
   const visibilityByDataPath = /* @__PURE__ */ new Map();
   const deprecationByDataPath = /* @__PURE__ */ new Map();
   const ajv = new Ajv__default["default"]({
@@ -325,6 +105,13 @@ function compileConfigSchemas(schemas) {
     }
   }
   const merged = mergeConfigSchemas(schemas.map((_) => _.value));
+  if (options == null ? void 0 : options.noUndeclaredProperties) {
+    traverse__default["default"](merged, (schema) => {
+      if ((schema == null ? void 0 : schema.type) === "object") {
+        schema.additionalProperties || (schema.additionalProperties = false);
+      }
+    });
+  }
   const validate = ajv.compile(merged);
   const visibilityBySchemaPath = /* @__PURE__ */ new Map();
   traverse__default["default"](merged, (schema, path) => {
@@ -651,7 +438,9 @@ async function loadConfigSchema(options) {
     }
     schemas = serialized.schemas;
   }
-  const validate = compileConfigSchemas(schemas);
+  const validate = compileConfigSchemas(schemas, {
+    noUndeclaredProperties: options.noUndeclaredProperties
+  });
   return {
     process(configs, {
       visibility,
@@ -711,173 +500,1183 @@ async function loadConfigSchema(options) {
   };
 }
 
-function isValidUrl(url) {
-  try {
-    new URL(url);
-    return true;
-  } catch {
-    return false;
+class EnvConfigSource {
+  constructor(env) {
+    this.env = env;
   }
-}
-
-async function loadConfig(options) {
-  const { configRoot, experimentalEnvFunc: envFunc, watch, remote } = options;
-  const configPaths = options.configTargets.slice().filter((e) => e.hasOwnProperty("path")).map((configTarget) => configTarget.path);
-  const configUrls = options.configTargets.slice().filter((e) => e.hasOwnProperty("url")).map((configTarget) => configTarget.url);
-  if (remote === void 0) {
-    if (configUrls.length > 0) {
-      throw new Error(
-        `Please make sure you are passing the remote option when loading remote configurations. See https://backstage.io/docs/conf/writing#configuration-files for detailed info.`
-      );
-    }
-  } else if (remote.reloadIntervalSeconds <= 0) {
-    throw new Error(
-      `Remote config must be contain a non zero reloadIntervalSeconds: <seconds> value`
-    );
+  /**
+   * 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) {
+    var _a;
+    return new EnvConfigSource((_a = options == null ? void 0 : options.env) != null ? _a : process.env);
   }
-  if (configPaths.length === 0 && configUrls.length === 0) {
-    configPaths.push(path.resolve(configRoot, "app-config.yaml"));
-    const localConfig = path.resolve(configRoot, "app-config.local.yaml");
-    if (await fs__default["default"].pathExists(localConfig)) {
-      configPaths.push(localConfig);
-    }
+  async *readConfigData() {
+    const configs = readEnvConfig(this.env);
+    yield { configs };
+    return;
   }
-  const env = envFunc != null ? envFunc : async (name) => process.env[name];
-  const loadConfigFiles = async () => {
-    const fileConfigs2 = [];
-    const loadedPaths2 = /* @__PURE__ */ new Set();
-    for (const configPath of configPaths) {
-      if (!path.isAbsolute(configPath)) {
-        throw new Error(`Config load path is not absolute: '${configPath}'`);
-      }
-      const dir = path.dirname(configPath);
-      const readFile = (path$1) => {
-        const fullPath = path.resolve(dir, path$1);
-        loadedPaths2.add(fullPath);
-        return fs__default["default"].readFile(fullPath, "utf8");
-      };
-      const input = yaml__default["default"].parse(await readFile(configPath));
-      if (input !== null) {
-        const substitutionTransform = createSubstitutionTransform(env);
-        const data = await applyConfigTransforms(dir, input, [
-          createIncludeTransform(env, readFile, substitutionTransform),
-          substitutionTransform
-        ]);
-        fileConfigs2.push({ data, context: path.basename(configPath) });
-      }
-    }
-    return { fileConfigs: fileConfigs2, loadedPaths: loadedPaths2 };
-  };
-  const loadRemoteConfigFiles = async () => {
-    const configs = [];
-    const readConfigFromUrl = async (url) => {
-      const response = await fetch__default["default"](url);
-      if (!response.ok) {
-        throw new Error(`Could not read config file at ${url}`);
-      }
-      return await response.text();
-    };
-    for (let i = 0; i < configUrls.length; i++) {
-      const configUrl = configUrls[i];
-      if (!isValidUrl(configUrl)) {
-        throw new Error(`Config load path is not valid: '${configUrl}'`);
-      }
-      const remoteConfigContent = await readConfigFromUrl(configUrl);
-      if (!remoteConfigContent) {
-        throw new Error(`Config is not valid`);
-      }
-      const configYaml = yaml__default["default"].parse(remoteConfigContent);
-      const substitutionTransform = createSubstitutionTransform(env);
-      const data = await applyConfigTransforms(configRoot, configYaml, [
-        substitutionTransform
-      ]);
-      configs.push({ data, context: configUrl });
-    }
-    return configs;
-  };
-  let fileConfigs;
-  let loadedPaths;
-  try {
-    ({ fileConfigs, loadedPaths } = await loadConfigFiles());
-  } catch (error) {
-    throw new errors.ForwardedError("Failed to read static configuration file", error);
+  toString() {
+    const keys = Object.keys(this.env).filter(
+      (key) => key.startsWith("APP_CONFIG_")
+    );
+    return `EnvConfigSource{count=${keys.length}}`;
   }
-  let remoteConfigs = [];
-  if (remote) {
-    try {
-      remoteConfigs = await loadRemoteConfigFiles();
-    } catch (error) {
-      throw new errors.ForwardedError(
-        `Failed to read remote configuration file`,
-        error
-      );
-    }
+}
+const ENV_PREFIX = "APP_CONFIG_";
+const CONFIG_KEY_PART_PATTERN = /^[a-z][a-z0-9]*(?:[-_][a-z][a-z0-9]*)*$/i;
+function readEnvConfig(env) {
+  var _a;
+  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 != null ? 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] = (_a = obj[part]) != null ? _a : {};
+          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 {
+        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) {
+    var _a;
+    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 = (_a = result == null ? void 0 : result.newDir) != null ? _a : 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 void 0;
+    } 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 == null ? void 0 : context.dir);
+  if (!isObject(finalData)) {
+    throw new TypeError("expected object at config root");
   }
-  const envConfigs = readEnvConfig(process.env);
-  const watchConfigFile = (watchProp) => {
-    let watchedFiles = Array.from(loadedPaths);
-    const watcher = chokidar__default["default"].watch(watchedFiles, {
+  return finalData;
+}
+function createConfigTransformer(options) {
+  const { substitutionFunc = async (name) => process.env[name], 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 != null ? ctx : {}, transforms);
+}
+
+var __accessCheck$3 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$2 = (obj, member, getter) => {
+  __accessCheck$3(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$3 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$2 = (obj, member, value, setter) => {
+  __accessCheck$3(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod$2 = (obj, member, method) => {
+  __accessCheck$3(obj, member, "access private method");
+  return method;
+};
+var _path, _substitutionFunc, _waitForEvent, waitForEvent_fn;
+async function readFile(path) {
+  try {
+    return await fs__default["default"].readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+const _FileConfigSource = class {
+  constructor(options) {
+    __privateAdd$3(this, _waitForEvent);
+    __privateAdd$3(this, _path, void 0);
+    __privateAdd$3(this, _substitutionFunc, void 0);
+    __privateSet$2(this, _path, options.path);
+    __privateSet$2(this, _substitutionFunc, options.substitutionFunc);
+  }
+  /**
+   * 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);
+  }
+  // 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 == null ? void 0 : options.signal;
+    const configFileName = path.basename(__privateGet$2(this, _path));
+    const watchedPaths = new Array();
+    const watcher = chokidar__default["default"].watch(__privateGet$2(this, _path), {
       usePolling: process.env.NODE_ENV === "test"
     });
-    let currentSerializedConfig = JSON.stringify(fileConfigs);
-    watcher.on("change", async () => {
+    const dir = path.dirname(__privateGet$2(this, _path));
+    const transformer = createConfigTransformer({
+      substitutionFunc: __privateGet$2(this, _substitutionFunc),
+      readFile: async (path$1) => {
+        const fullPath = path.resolve(dir, path$1);
+        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 () => {
+      watcher.unwatch(watchedPaths);
+      watchedPaths.length = 0;
+      watcher.add(__privateGet$2(this, _path));
+      watchedPaths.push(__privateGet$2(this, _path));
+      const content = await readFile(__privateGet$2(this, _path));
+      if (content === void 0) {
+        throw new errors.NotFoundError(`Config file "${__privateGet$2(this, _path)}" does not exist`);
+      }
+      const parsed = yaml__default["default"].parse(content);
+      if (parsed === null) {
+        return [];
+      }
       try {
-        const { fileConfigs: newConfigs, loadedPaths: newLoadedPaths } = await loadConfigFiles();
-        watcher.unwatch(watchedFiles);
-        watchedFiles = Array.from(newLoadedPaths);
-        watcher.add(watchedFiles);
-        const newSerializedConfig = JSON.stringify(newConfigs);
-        if (currentSerializedConfig === newSerializedConfig) {
-          return;
+        const data = await transformer(parsed, { dir });
+        return [{ data, context: configFileName, path: __privateGet$2(this, _path) }];
+      } catch (error) {
+        throw new Error(
+          `Failed to read config file at "${__privateGet$2(this, _path)}", ${error.message}`
+        );
+      }
+    };
+    const onAbort = () => {
+      signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
+      watcher.close();
+    };
+    signal == null ? void 0 : signal.addEventListener("abort", onAbort);
+    yield { configs: await readConfigFile() };
+    for (; ; ) {
+      const event = await __privateMethod$2(this, _waitForEvent, waitForEvent_fn).call(this, watcher, signal);
+      if (event === "abort") {
+        return;
+      }
+      yield { configs: await readConfigFile() };
+    }
+  }
+  toString() {
+    return `FileConfigSource{path="${__privateGet$2(this, _path)}"}`;
+  }
+};
+let FileConfigSource = _FileConfigSource;
+_path = new WeakMap();
+_substitutionFunc = new WeakMap();
+_waitForEvent = new WeakSet();
+waitForEvent_fn = function(watcher, signal) {
+  return new Promise((resolve) => {
+    function onChange() {
+      resolve("change");
+      onDone();
+    }
+    function onAbort() {
+      resolve("abort");
+      onDone();
+    }
+    function onDone() {
+      watcher.removeListener("change", onChange);
+      signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
+    }
+    watcher.addListener("change", onChange);
+    signal == null ? void 0 : signal.addEventListener("abort", onAbort);
+  });
+};
+
+var __accessCheck$2 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateAdd$2 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod$1 = (obj, member, method) => {
+  __accessCheck$2(obj, member, "access private method");
+  return method;
+};
+var _flattenSources, flattenSources_fn;
+const sourcesSymbol = Symbol.for(
+  "@backstage/config-loader#MergedConfigSource.sources"
+);
+const _MergedConfigSource = class {
+  constructor(sources) {
+    this.sources = sources;
+    this[sourcesSymbol] = this.sources;
+  }
+  static from(sources) {
+    return new _MergedConfigSource(__privateMethod$1(this, _flattenSources, flattenSources_fn).call(this, sources));
+  }
+  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(", ")}}`;
+  }
+};
+let MergedConfigSource = _MergedConfigSource;
+_flattenSources = new WeakSet();
+flattenSources_fn = function(sources) {
+  return sources.flatMap((source) => {
+    if (sourcesSymbol in source && Array.isArray(source[sourcesSymbol])) {
+      return __privateMethod$1(this, _flattenSources, flattenSources_fn).call(this, source[sourcesSymbol]);
+    }
+    return source;
+  });
+};
+// An optimization to flatten nested merged sources to avid unnecessary microtasks
+__privateAdd$2(MergedConfigSource, _flattenSources);
+function nextWithIndex(iterator, index) {
+  return iterator.next().then(
+    (r) => [index, r],
+    (e) => {
+      throw Object.assign(e, { index });
+    }
+  );
+}
+
+var __accessCheck$1 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$1 = (obj, member, getter) => {
+  __accessCheck$1(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$1 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$1 = (obj, member, value, setter) => {
+  __accessCheck$1(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck$1(obj, member, "access private method");
+  return method;
+};
+var _url, _reloadIntervalMs, _transformer, _load, load_fn, _wait, wait_fn;
+const DEFAULT_RELOAD_INTERVAL = { seconds: 60 };
+function durationToMs(duration) {
+  const {
+    years = 0,
+    months = 0,
+    weeks = 0,
+    days = 0,
+    hours = 0,
+    minutes = 0,
+    seconds = 0,
+    milliseconds = 0
+  } = duration;
+  const totalDays = years * 365 + months * 30 + weeks * 7 + days;
+  const totalHours = totalDays * 24 + hours;
+  const totalMinutes = totalHours * 60 + minutes;
+  const totalSeconds = totalMinutes * 60 + seconds;
+  const totalMilliseconds = totalSeconds * 1e3 + milliseconds;
+  return totalMilliseconds;
+}
+const _RemoteConfigSource = class {
+  constructor(options) {
+    __privateAdd$1(this, _load);
+    __privateAdd$1(this, _wait);
+    __privateAdd$1(this, _url, void 0);
+    __privateAdd$1(this, _reloadIntervalMs, void 0);
+    __privateAdd$1(this, _transformer, void 0);
+    var _a;
+    __privateSet$1(this, _url, options.url);
+    __privateSet$1(this, _reloadIntervalMs, durationToMs(
+      (_a = options.reloadInterval) != null ? _a : DEFAULT_RELOAD_INTERVAL
+    ));
+    __privateSet$1(this, _transformer, createConfigTransformer({
+      substitutionFunc: options.substitutionFunc
+    }));
+  }
+  /**
+   * 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);
+  }
+  async *readConfigData(options) {
+    var _a;
+    let data = await __privateMethod(this, _load, load_fn).call(this);
+    yield { configs: [{ data, context: __privateGet$1(this, _url) }] };
+    for (; ; ) {
+      await __privateMethod(this, _wait, wait_fn).call(this, options == null ? void 0 : options.signal);
+      if ((_a = options == null ? void 0 : options.signal) == null ? void 0 : _a.aborted) {
+        return;
+      }
+      try {
+        const newData = await __privateMethod(this, _load, load_fn).call(this, options == null ? void 0 : options.signal);
+        if (newData && !isEqual__default["default"](data, newData)) {
+          data = newData;
+          yield { configs: [{ data, context: __privateGet$1(this, _url) }] };
         }
-        currentSerializedConfig = newSerializedConfig;
-        watchProp.onChange([...remoteConfigs, ...newConfigs, ...envConfigs]);
       } catch (error) {
-        console.error(`Failed to reload configuration files, ${error}`);
+        if (error.name !== "AbortError") {
+          console.error(`Failed to read config from ${__privateGet$1(this, _url)}, ${error}`);
+        }
+      }
+    }
+  }
+  toString() {
+    return `RemoteConfigSource{path="${__privateGet$1(this, _url)}"}`;
+  }
+};
+let RemoteConfigSource = _RemoteConfigSource;
+_url = new WeakMap();
+_reloadIntervalMs = new WeakMap();
+_transformer = new WeakMap();
+_load = new WeakSet();
+load_fn = async function(signal) {
+  const res = await fetch__default["default"](__privateGet$1(this, _url), {
+    signal
+  });
+  if (!res.ok) {
+    throw await errors.ResponseError.fromResponse(res);
+  }
+  const content = await res.text();
+  const data = await __privateGet$1(this, _transformer).call(this, yaml__default["default"].parse(content));
+  if (data === null) {
+    throw new Error("configuration data is null");
+  } else 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;
+};
+_wait = new WeakSet();
+wait_fn = async function(signal) {
+  return new Promise((resolve) => {
+    const timeoutId = setTimeout(onDone, __privateGet$1(this, _reloadIntervalMs));
+    signal == null ? void 0 : signal.addEventListener("abort", onDone);
+    function onDone() {
+      clearTimeout(timeoutId);
+      signal == null ? void 0 : signal.removeEventListener("abort", onDone);
+      resolve();
+    }
+  });
+};
+
+class ObservableConfigProxy {
+  constructor(parent, parentKey, abortController) {
+    this.parent = parent;
+    this.parentKey = parentKey;
+    this.abortController = abortController;
+    this.config = new config.ConfigReader({});
+    this.subscribers = [];
+    if (parent && !parentKey) {
+      throw new Error("parentKey is required if parent is set");
+    }
+  }
+  static create(abortController) {
+    return new ObservableConfigProxy(void 0, void 0, abortController);
+  }
+  setConfig(config) {
+    if (this.parent) {
+      throw new Error("immutable");
+    }
+    this.config = config;
+    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) {
+    var _a;
+    if (this.parent && this.parentKey) {
+      if (required) {
+        return this.parent.select(true).getConfig(this.parentKey);
+      }
+      return (_a = this.parent.select(false)) == null ? void 0 : _a.getOptionalConfig(this.parentKey);
+    }
+    return this.config;
+  }
+  has(key) {
+    var _a, _b;
+    return (_b = (_a = this.select(false)) == null ? void 0 : _a.has(key)) != null ? _b : false;
+  }
+  keys() {
+    var _a, _b;
+    return (_b = (_a = this.select(false)) == null ? void 0 : _a.keys()) != null ? _b : [];
+  }
+  get(key) {
+    return this.select(true).get(key);
+  }
+  getOptional(key) {
+    var _a;
+    return (_a = this.select(false)) == null ? void 0 : _a.getOptional(key);
+  }
+  getConfig(key) {
+    return new ObservableConfigProxy(this, key);
+  }
+  getOptionalConfig(key) {
+    var _a;
+    if ((_a = this.select(false)) == null ? void 0 : _a.has(key)) {
+      return new ObservableConfigProxy(this, key);
+    }
+    return void 0;
+  }
+  getConfigArray(key) {
+    return this.select(true).getConfigArray(key);
+  }
+  getOptionalConfigArray(key) {
+    var _a;
+    return (_a = this.select(false)) == null ? void 0 : _a.getOptionalConfigArray(key);
+  }
+  getNumber(key) {
+    return this.select(true).getNumber(key);
+  }
+  getOptionalNumber(key) {
+    var _a;
+    return (_a = this.select(false)) == null ? void 0 : _a.getOptionalNumber(key);
+  }
+  getBoolean(key) {
+    return this.select(true).getBoolean(key);
+  }
+  getOptionalBoolean(key) {
+    var _a;
+    return (_a = this.select(false)) == null ? void 0 : _a.getOptionalBoolean(key);
+  }
+  getString(key) {
+    return this.select(true).getString(key);
+  }
+  getOptionalString(key) {
+    var _a;
+    return (_a = this.select(false)) == null ? void 0 : _a.getOptionalString(key);
+  }
+  getStringArray(key) {
+    return this.select(true).getStringArray(key);
+  }
+  getOptionalStringArray(key) {
+    var _a;
+    return (_a = this.select(false)) == null ? void 0 : _a.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 };
       }
     });
-    if (watchProp.stopSignal) {
-      watchProp.stopSignal.then(() => {
-        watcher.close();
+  }
+  /**
+   * 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) {
+    var _a;
+    const rootDir = (_a = options.rootDir) != null ? _a : 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({
+        path: 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");
+      argSources.push(
+        FileConfigSource.create({
+          path: defaultPath,
+          substitutionFunc: options.substitutionFunc
+        })
+      );
+      if (fs__default["default"].pathExistsSync(localPath)) {
+        argSources.push(
+          FileConfigSource.create({
+            path: localPath,
+            substitutionFunc: options.substitutionFunc
+          })
+        );
+      }
     }
-  };
-  const watchRemoteConfig = (watchProp, remoteProp) => {
-    const hasConfigChanged = async (oldRemoteConfigs, newRemoteConfigs) => {
-      return JSON.stringify(oldRemoteConfigs) !== JSON.stringify(newRemoteConfigs);
+    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);
+      }
+    });
+  }
+}
+
+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]);
     };
-    let handle;
-    try {
-      handle = setInterval(async () => {
-        const newRemoteConfigs = await loadRemoteConfigFiles();
-        if (await hasConfigChanged(remoteConfigs, newRemoteConfigs)) {
-          remoteConfigs = newRemoteConfigs;
-          watchProp.onChange([...remoteConfigs, ...fileConfigs, ...envConfigs]);
+    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));
+  });
+}
+
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _currentData, _deferred, _context, _abortController;
+const _MutableConfigSource = class {
+  constructor(context, initialData) {
+    __privateAdd(this, _currentData, void 0);
+    __privateAdd(this, _deferred, void 0);
+    __privateAdd(this, _context, void 0);
+    __privateAdd(this, _abortController, new AbortController());
+    __privateSet(this, _currentData, initialData);
+    __privateSet(this, _context, context);
+    __privateSet(this, _deferred, simpleDefer());
+  }
+  /**
+   * Creates a new mutable config source.
+   *
+   * @param options - Options for the config source.
+   * @returns A new mutable config source.
+   */
+  static create(options) {
+    var _a;
+    return new _MutableConfigSource(
+      (_a = options == null ? void 0 : options.context) != null ? _a : "mutable-config",
+      options == null ? void 0 : options.data
+    );
+  }
+  async *readConfigData(options) {
+    let deferredPromise = __privateGet(this, _deferred).promise;
+    if (__privateGet(this, _currentData) !== void 0) {
+      yield { configs: [{ data: __privateGet(this, _currentData), context: __privateGet(this, _context) }] };
+    }
+    for (; ; ) {
+      const [ok] = await waitOrAbort(deferredPromise, [
+        options == null ? void 0 : options.signal,
+        __privateGet(this, _abortController).signal
+      ]);
+      if (!ok) {
+        return;
+      }
+      deferredPromise = __privateGet(this, _deferred).promise;
+      if (__privateGet(this, _currentData) !== void 0) {
+        yield {
+          configs: [{ data: __privateGet(this, _currentData), context: __privateGet(this, _context) }]
+        };
+      }
+    }
+  }
+  /**
+   * Set the data of the config source.
+   *
+   * @param data - The new data to set
+   */
+  setData(data) {
+    if (!__privateGet(this, _abortController).signal.aborted) {
+      __privateSet(this, _currentData, data);
+      const oldDeferred = __privateGet(this, _deferred);
+      __privateSet(this, _deferred, simpleDefer());
+      oldDeferred.resolve();
+    }
+  }
+  /**
+   * Close the config source, preventing any further updates.
+   */
+  close() {
+    __privateSet(this, _currentData, void 0);
+    __privateGet(this, _abortController).abort();
+  }
+  toString() {
+    return `MutableConfigSource{}`;
+  }
+};
+let MutableConfigSource = _MutableConfigSource;
+_currentData = new WeakMap();
+_deferred = new WeakMap();
+_context = new WeakMap();
+_abortController = new WeakMap();
+
+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 == null ? void 0 : 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;
         }
-      }, remoteProp.reloadIntervalSeconds * 1e3);
-    } catch (error) {
-      console.error(`Failed to reload configuration files, ${error}`);
+      };
+    }
+    if (isObservable(data)) {
+      return new StaticObservableConfigSource(data, context);
     }
-    if (watchProp.stopSignal) {
-      watchProp.stopSignal.then(() => {
-        if (handle !== void 0) {
-          clearInterval(handle);
-          handle = void 0;
+    if (isAsyncIterable(data)) {
+      return {
+        async *readConfigData() {
+          for await (const value of data) {
+            yield { configs: [{ data: value, context }] };
+          }
         }
-      });
+      };
     }
-  };
-  if (watch) {
-    watchConfigFile(watch);
+    return new StaticConfigSource(data, context);
   }
-  if (watch && remote) {
-    watchRemoteConfig(watch, remote);
+  async *readConfigData() {
+    yield { configs: [{ data: await this.promise, context: this.context }] };
+    return;
   }
-  return {
-    appConfigs: remote ? [...remoteConfigs, ...fileConfigs, ...envConfigs] : [...fileConfigs, ...envConfigs]
-  };
+  toString() {
+    return `StaticConfigSource{}`;
+  }
+}
+
+async function loadConfig(options) {
+  const source = ConfigSources.default({
+    substitutionFunc: options.experimentalEnvFunc,
+    remote: options.remote && {
+      reloadInterval: { seconds: options.remote.reloadIntervalSeconds }
+    },
+    rootDir: options.configRoot,
+    argv: options.configTargets.flatMap((t) => [
+      "--config",
+      "url" in t ? t.url : t.path
+    ])
+  });
+  return new Promise((resolve, reject) => {
+    async function loadConfigReaderLoop() {
+      var _a, _b, _c, _d;
+      let loaded = false;
+      try {
+        const abortController = new AbortController();
+        (_b = (_a = options.watch) == null ? void 0 : _a.stopSignal) == null ? void 0 : _b.then(() => abortController.abort());
+        for await (const { configs } of source.readConfigData({
+          signal: abortController.signal
+        })) {
+          if (loaded) {
+            (_c = options.watch) == null ? void 0 : _c.onChange(configs);
+          } else {
+            resolve({ appConfigs: configs });
+            loaded = true;
+            if (options.watch) {
+              (_d = options.watch.stopSignal) == null ? void 0 : _d.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;