@lorion-org/runtime-config-node 1.0.0-beta.0

package/dist/index.cjs

@@ -0,0 +1,586 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  collectRuntimeConfigFragmentFiles: () => collectRuntimeConfigFragmentFiles,
+  ensureParentDir: () => ensureParentDir,
+  getRuntimeConfigScopeView: () => getRuntimeConfigScopeView,
+  getRuntimeConfigValue: () => getRuntimeConfigValue,
+  listRuntimeConfigFragments: () => listRuntimeConfigFragments,
+  listRuntimeConfigScopeFiles: () => listRuntimeConfigScopeFiles,
+  loadRuntimeConfigEnvVars: () => loadRuntimeConfigEnvVars,
+  loadRuntimeConfigFragment: () => loadRuntimeConfigFragment,
+  loadRuntimeConfigShellAssignments: () => loadRuntimeConfigShellAssignments,
+  loadRuntimeConfigSourceTree: () => loadRuntimeConfigSourceTree,
+  loadRuntimeConfigTree: () => loadRuntimeConfigTree,
+  parseRuntimeConfigFragmentFiles: () => parseRuntimeConfigFragmentFiles,
+  projectRuntimeConfigTree: () => projectRuntimeConfigTree,
+  readJsonFile: () => readJsonFile,
+  readRequiredJsonFile: () => readRequiredJsonFile,
+  readRuntimeConfigScopeJson: () => readRuntimeConfigScopeJson,
+  readTextFile: () => readTextFile,
+  resolveRuntimeConfigFilePath: () => resolveRuntimeConfigFilePath,
+  resolveRuntimeConfigPaths: () => resolveRuntimeConfigPaths,
+  resolveRuntimeConfigPublicFilePath: () => resolveRuntimeConfigPublicFilePath,
+  resolveRuntimeConfigPublicRootPath: () => resolveRuntimeConfigPublicRootPath,
+  resolveRuntimeConfigScopeFilePath: () => resolveRuntimeConfigScopeFilePath,
+  resolveRuntimeConfigSource: () => resolveRuntimeConfigSource,
+  resolveRuntimeConfigSourceFiles: () => resolveRuntimeConfigSourceFiles,
+  resolveRuntimeConfigSourcePublicRootPath: () => resolveRuntimeConfigSourcePublicRootPath,
+  showRuntimeConfigFragment: () => showRuntimeConfigFragment,
+  validateRuntimeConfigSchemaTargets: () => validateRuntimeConfigSchemaTargets,
+  validateRuntimeConfigScopes: () => validateRuntimeConfigScopes,
+  validateRuntimeConfigSourceScopes: () => validateRuntimeConfigSourceScopes,
+  writeJsonFile: () => writeJsonFile,
+  writeRuntimeConfigFragment: () => writeRuntimeConfigFragment,
+  writeRuntimeConfigScopeJson: () => writeRuntimeConfigScopeJson,
+  writeTextFile: () => writeTextFile
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"), 1);
+var import_ajv = __toESM(require("ajv"), 1);
+var import_runtime_config = require("@lorion-org/runtime-config");
+var defaultRuntimeConfigFileName = "runtime.config.json";
+var defaultRuntimeConfigDirName = "runtime-config";
+var defaultRuntimeConfigSchemaFileName = "runtime-config.schema.json";
+function toPosixPath(filePath) {
+  return filePath.split(import_node_path.default.sep).join("/");
+}
+function escapeRegex(value) {
+  return value.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+}
+function countWildcards(pattern) {
+  return (pattern.match(/\*/g) ?? []).length;
+}
+function assertSingleWildcardPattern(pattern) {
+  const wildcardCount = countWildcards(pattern);
+  if (wildcardCount !== 1) {
+    throw new Error(
+      `RuntimeConfig path pattern must contain exactly one "*" wildcard: "${pattern}"`
+    );
+  }
+}
+function createGlobSegmentRegex(segment) {
+  return new RegExp(`^${segment.split("*").map(escapeRegex).join("[^/\\\\]*")}$`);
+}
+function splitAbsolutePattern(pattern) {
+  const absolutePattern = import_node_path.default.resolve(pattern);
+  const parsed = import_node_path.default.parse(absolutePattern);
+  const relativePattern = import_node_path.default.relative(parsed.root, absolutePattern);
+  return {
+    root: parsed.root,
+    segments: relativePattern.split(/[\\/]+/).filter(Boolean)
+  };
+}
+function expandRuntimeConfigPattern(pattern) {
+  assertSingleWildcardPattern(pattern);
+  const { root, segments } = splitAbsolutePattern(pattern);
+  const visit = (currentDir, index) => {
+    const segment = segments[index];
+    if (!segment) return [];
+    const isLast = index === segments.length - 1;
+    if (!segment.includes("*")) {
+      const nextPath = import_node_path.default.join(currentDir, segment);
+      if (isLast) return (0, import_node_fs.existsSync)(nextPath) ? [nextPath] : [];
+      if (!(0, import_node_fs.existsSync)(nextPath)) return [];
+      return visit(nextPath, index + 1);
+    }
+    if (!(0, import_node_fs.existsSync)(currentDir)) return [];
+    const matcher = createGlobSegmentRegex(segment);
+    return (0, import_node_fs.readdirSync)(currentDir, { withFileTypes: true }).filter((entry) => entry.name !== "node_modules" && matcher.test(entry.name)).flatMap((entry) => {
+      const nextPath = import_node_path.default.join(currentDir, entry.name);
+      if (isLast) return entry.isFile() ? [nextPath] : [];
+      return entry.isDirectory() ? visit(nextPath, index + 1) : [];
+    });
+  };
+  return visit(root, 0);
+}
+function getRuntimeConfigScopeIdFromPattern(input) {
+  assertSingleWildcardPattern(input.pattern);
+  const resolvedPattern = import_node_path.default.resolve(input.pattern);
+  const wildcardIndex = resolvedPattern.indexOf("*");
+  const beforeWildcard = resolvedPattern.slice(0, wildcardIndex);
+  const afterWildcard = resolvedPattern.slice(wildcardIndex + 1);
+  const configPath = import_node_path.default.resolve(input.configPath);
+  if (!configPath.startsWith(beforeWildcard) || !configPath.endsWith(afterWildcard)) {
+    throw new Error(
+      `RuntimeConfig file "${input.configPath}" does not match pattern "${input.pattern}"`
+    );
+  }
+  return toPosixPath(
+    configPath.slice(beforeWildcard.length, configPath.length - afterWildcard.length)
+  ).replace(/^\/+|\/+$/g, "");
+}
+function getRuntimeConfigPatternPublicRoot(pattern) {
+  assertSingleWildcardPattern(pattern);
+  const resolvedPattern = import_node_path.default.resolve(pattern);
+  const beforeWildcard = resolvedPattern.slice(0, resolvedPattern.indexOf("*"));
+  const wildcardParent = beforeWildcard.replace(/[\\/]+$/, "");
+  return import_node_path.default.resolve(wildcardParent, "public");
+}
+function getFileName(options) {
+  return options.fileName ?? defaultRuntimeConfigFileName;
+}
+function getRuntimeConfigDirName(options) {
+  return options.runtimeConfigDirName ?? defaultRuntimeConfigDirName;
+}
+function getRuntimeConfigPathOptions(source) {
+  return {
+    ...source.fileName ? { fileName: source.fileName } : {},
+    ...source.runtimeConfigDirName ? { runtimeConfigDirName: source.runtimeConfigDirName } : {}
+  };
+}
+function getSchemaFileName(options) {
+  return options.schemaFileName ?? defaultRuntimeConfigSchemaFileName;
+}
+function stripJsonBom(text) {
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+function ensureParentDir(filePath) {
+  const dirPath = import_node_path.default.dirname(filePath);
+  if (!(0, import_node_fs.existsSync)(dirPath)) (0, import_node_fs.mkdirSync)(dirPath, { recursive: true });
+}
+function readTextFile(filePath) {
+  return (0, import_node_fs.existsSync)(filePath) ? (0, import_node_fs.readFileSync)(filePath, "utf8") : void 0;
+}
+function writeTextFile(filePath, data, options = {}) {
+  if (options.createDir !== false) ensureParentDir(filePath);
+  (0, import_node_fs.writeFileSync)(filePath, data, "utf8");
+}
+function readJsonFile(filePath, options = {}) {
+  const text = readTextFile(filePath);
+  if (text === void 0) return void 0;
+  try {
+    return JSON.parse(stripJsonBom(text));
+  } catch (error) {
+    options.onParseError?.(error, filePath);
+    return options.defaultValue;
+  }
+}
+function readRequiredJsonFile(filePath) {
+  const text = readTextFile(filePath);
+  if (text === void 0) {
+    throw new Error(`RuntimeConfig JSON file not found: "${filePath}"`);
+  }
+  try {
+    return JSON.parse(stripJsonBom(text));
+  } catch (error) {
+    throw new Error(`RuntimeConfig JSON parse error in "${filePath}": ${String(error)}`);
+  }
+}
+function writeJsonFile(filePath, data, options = {}) {
+  const spacing = options.pretty === false ? void 0 : 2;
+  writeTextFile(filePath, `${JSON.stringify(data, void 0, spacing)}
+`, options);
+}
+function resolveRuntimeConfigPaths(varDir, scopeId, options = {}) {
+  const runtimeConfigDir = import_node_path.default.join(varDir, getRuntimeConfigDirName(options));
+  const scopeDir = import_node_path.default.join(runtimeConfigDir, scopeId);
+  const filePath = import_node_path.default.join(scopeDir, getFileName(options));
+  return {
+    varDir,
+    runtimeConfigDir,
+    scopeDir,
+    filePath
+  };
+}
+function resolveRuntimeConfigSource(options = {}) {
+  const envKey = options.envKey ?? "RUNTIME_CONFIG_VAR_DIR";
+  const varDir = String(
+    options.varDir ?? options.env?.[envKey] ?? options.defaultVarDir ?? ""
+  ).trim();
+  if (!varDir) {
+    throw new Error(`RuntimeConfig varDir not found. Pass varDir or set ${envKey}.`);
+  }
+  return {
+    varDir,
+    ...options.fileName ? { fileName: options.fileName } : {},
+    ...options.runtimeConfigDirName ? { runtimeConfigDirName: options.runtimeConfigDirName } : {}
+  };
+}
+function resolveRuntimeConfigFilePath(varDir, scopeId, filename, options = {}) {
+  const { scopeDir } = resolveRuntimeConfigPaths(varDir, scopeId, options);
+  return import_node_path.default.join(scopeDir, filename);
+}
+function resolveRuntimeConfigScopeFilePath(source, scopeId, fileName) {
+  return resolveRuntimeConfigFilePath(
+    source.varDir,
+    scopeId,
+    fileName,
+    getRuntimeConfigPathOptions(source)
+  );
+}
+function readRuntimeConfigScopeJson(source, scopeId, fileName, options = {}) {
+  return readJsonFile(resolveRuntimeConfigScopeFilePath(source, scopeId, fileName), options);
+}
+function writeRuntimeConfigScopeJson(source, scopeId, fileName, data, options = {}) {
+  writeJsonFile(resolveRuntimeConfigScopeFilePath(source, scopeId, fileName), data, options);
+}
+function resolveRuntimeConfigPublicRootPath(source) {
+  return import_node_path.default.resolve(
+    source.varDir,
+    getRuntimeConfigDirName(getRuntimeConfigPathOptions(source)),
+    "public"
+  );
+}
+function resolveRuntimeConfigPublicFilePath(source, relativePath) {
+  return import_node_path.default.resolve(resolveRuntimeConfigPublicRootPath(source), relativePath);
+}
+function resolveRuntimeConfigSourceFiles(source) {
+  return source.paths.flatMap(
+    (pattern) => expandRuntimeConfigPattern(pattern).map((configPath) => ({
+      configPath,
+      pattern,
+      scopeId: getRuntimeConfigScopeIdFromPattern({ configPath, pattern })
+    }))
+  ).filter((entry, index, entries) => {
+    return entries.findIndex((candidate) => candidate.configPath === entry.configPath) === index;
+  }).sort((left, right) => left.configPath.localeCompare(right.configPath));
+}
+function loadRuntimeConfigSourceTree(source) {
+  const fragments = /* @__PURE__ */ new Map();
+  for (const entry of resolveRuntimeConfigSourceFiles(source)) {
+    const config = readJsonFile(entry.configPath);
+    if (config) fragments.set(entry.scopeId, config);
+  }
+  return fragments;
+}
+function resolveRuntimeConfigSourcePublicRootPath(source) {
+  const pattern = source.paths[0];
+  return pattern ? getRuntimeConfigPatternPublicRoot(pattern) : void 0;
+}
+function listRuntimeConfigScopeFiles(varDir, scopeId, subdir, options = {}) {
+  const dirPath = resolveRuntimeConfigFilePath(varDir, scopeId, subdir, options);
+  if (!(0, import_node_fs.existsSync)(dirPath)) return [];
+  return (0, import_node_fs.readdirSync)(dirPath, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => options.extension ? name.endsWith(options.extension) : true);
+}
+function collectRuntimeConfigFragmentFiles(runtimeConfigDir, options = {}) {
+  const fileName = getFileName(options);
+  const files = [];
+  if (!(0, import_node_fs.existsSync)(runtimeConfigDir)) return files;
+  const walk = (currentPath) => {
+    for (const entry of (0, import_node_fs.readdirSync)(currentPath, { withFileTypes: true })) {
+      const absolutePath = import_node_path.default.resolve(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        walk(absolutePath);
+        continue;
+      }
+      if (entry.isFile() && entry.name === fileName) {
+        files.push(absolutePath);
+      }
+    }
+  };
+  walk(runtimeConfigDir);
+  return files.sort((left, right) => left.localeCompare(right));
+}
+function parseRuntimeConfigFragmentFiles(filePaths, runtimeConfigDir, options = {}) {
+  const fileName = getFileName(options);
+  const fragments = /* @__PURE__ */ new Map();
+  for (const filePath of filePaths) {
+    const relativePath = toPosixPath(import_node_path.default.relative(runtimeConfigDir, filePath));
+    const scopeId = relativePath.replace(
+      new RegExp(`/${fileName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`),
+      ""
+    );
+    const config = readJsonFile(filePath);
+    if (config) fragments.set(scopeId, config);
+  }
+  return fragments;
+}
+function loadRuntimeConfigFragment(varDir, scopeId, options = {}) {
+  const { filePath } = resolveRuntimeConfigPaths(varDir, scopeId, options);
+  return readJsonFile(filePath);
+}
+function writeRuntimeConfigFragment(varDir, scopeId, config, options = {}) {
+  const { filePath } = resolveRuntimeConfigPaths(varDir, scopeId, options);
+  writeJsonFile(filePath, config, options);
+}
+function formatRuntimeConfigSchemaValidationError(target, validationError) {
+  const jsonPath = validationError.instancePath || "/";
+  const ajvError = `${validationError.keyword}${validationError.message ? `: ${validationError.message}` : ""}`;
+  return new Error(
+    [
+      "RuntimeConfig schema validation failed.",
+      `Scope: ${target.scopeId}`,
+      `File: ${target.configPath}`,
+      `JSON path: ${jsonPath}`,
+      `Schema error: ${ajvError}`
+    ].join("\n")
+  );
+}
+function validateRuntimeConfigSchemaTargets(targets, options = {}) {
+  const ajv = new import_ajv.default({
+    strict: false,
+    allErrors: false,
+    ...options.ajvOptions
+  });
+  const formatError = options.formatError ?? formatRuntimeConfigSchemaValidationError;
+  for (const target of targets) {
+    if (!(0, import_node_fs.existsSync)(target.schemaPath) || !(0, import_node_fs.existsSync)(target.configPath)) {
+      continue;
+    }
+    const schema = readRequiredJsonFile(target.schemaPath);
+    const runtimeConfig = readRequiredJsonFile(target.configPath);
+    const validate = ajv.compile(schema);
+    const isValid = validate(runtimeConfig);
+    if (!isValid) {
+      const validationError = validate.errors?.[0];
+      if (validationError) {
+        throw formatError(target, validationError);
+      }
+      throw new Error(
+        `RuntimeConfig schema validation failed for "${target.scopeId}" (${target.configPath})`
+      );
+    }
+  }
+}
+function loadRuntimeConfigTree(varDir, options = {}) {
+  const runtimeConfigDir = import_node_path.default.join(varDir, getRuntimeConfigDirName(options));
+  const filePaths = collectRuntimeConfigFragmentFiles(runtimeConfigDir, options);
+  return parseRuntimeConfigFragmentFiles(filePaths, runtimeConfigDir, options);
+}
+function loadRuntimeConfigEnvVars(varDir, options = {}) {
+  const { fileName, runtimeConfigDirName, ...envOptions } = options;
+  return (0, import_runtime_config.projectRuntimeConfigEnvVars)(
+    loadRuntimeConfigTree(varDir, {
+      ...fileName ? { fileName } : {},
+      ...runtimeConfigDirName ? { runtimeConfigDirName } : {}
+    }),
+    envOptions
+  );
+}
+function loadRuntimeConfigShellAssignments(varDir, options = {}) {
+  return (0, import_runtime_config.runtimeEnvVarsToShellAssignments)(loadRuntimeConfigEnvVars(varDir, options));
+}
+function listRuntimeConfigFragments(varDir, options = {}) {
+  const { contextInputKey, ...pathOptions } = options;
+  const fragments = loadRuntimeConfigTree(varDir, pathOptions);
+  const scopes = Array.from(fragments.entries()).map(([scopeId, config]) => {
+    const fragment = contextInputKey ? (0, import_runtime_config.toRuntimeConfigFragment)(config, { contextInputKey }) : config;
+    return {
+      contextIds: Object.keys(fragment.contexts ?? {}).sort(),
+      path: resolveRuntimeConfigPaths(varDir, scopeId, pathOptions).filePath,
+      privateKeys: Object.keys(config.private ?? {}).sort(),
+      publicKeys: Object.keys(config.public ?? {}).sort(),
+      scopeId
+    };
+  }).sort((left, right) => left.scopeId.localeCompare(right.scopeId));
+  return {
+    fileName: getFileName(pathOptions),
+    scopes,
+    varDir
+  };
+}
+function showRuntimeConfigFragment(varDir, scopeId, options = {}) {
+  const normalizedScopeId = scopeId.trim();
+  const config = normalizedScopeId ? loadRuntimeConfigFragment(varDir, normalizedScopeId, options) : void 0;
+  return {
+    fileName: getFileName(options),
+    path: resolveRuntimeConfigPaths(varDir, normalizedScopeId, options).filePath,
+    scopeId: normalizedScopeId,
+    varDir,
+    exists: Boolean(config),
+    ...config ? { config } : {}
+  };
+}
+function projectRuntimeConfigTree(varDir, options = {}) {
+  const fragments = loadRuntimeConfigTree(varDir, options);
+  const scopeIds = options.scopeIds?.length ? options.scopeIds : Array.from(fragments.keys()).sort();
+  return {
+    fileName: getFileName(options),
+    runtimeConfig: (0, import_runtime_config.projectSectionedRuntimeConfig)(fragments, {
+      ...options.contextInputKey ? { contextInputKey: options.contextInputKey } : {},
+      ...options.contextOutputKey ? { contextOutputKey: options.contextOutputKey } : {},
+      scopeIds
+    }),
+    scopeIds,
+    varDir
+  };
+}
+function getRuntimeConfigValue(varDir, scopeId, key, options = {}) {
+  const normalizedScopeId = scopeId.trim();
+  const normalizedKey = key.trim();
+  const visibility = options.visibility ?? "public";
+  const runtimeConfig = projectRuntimeConfigTree(varDir, {
+    ...options,
+    scopeIds: normalizedScopeId ? [normalizedScopeId] : []
+  }).runtimeConfig;
+  const value = (0, import_runtime_config.resolveRuntimeConfigValueFromRuntimeConfig)(
+    runtimeConfig,
+    normalizedScopeId,
+    normalizedKey,
+    {
+      ...options.contextId ? { contextId: options.contextId } : {},
+      ...options.contextOutputKey ? { contextOutputKey: options.contextOutputKey } : {},
+      visibility
+    }
+  );
+  return {
+    fileName: getFileName(options),
+    key: normalizedKey,
+    scopeId: normalizedScopeId,
+    varDir,
+    visibility,
+    ...options.contextId ? { contextId: options.contextId } : {},
+    exists: value !== void 0,
+    ...value !== void 0 ? { value } : {}
+  };
+}
+function getRuntimeConfigScopeView(varDir, scopeId, options = {}) {
+  const normalizedScopeId = scopeId.trim();
+  const visibility = options.visibility ?? "public";
+  const runtimeConfig = projectRuntimeConfigTree(varDir, {
+    ...options,
+    scopeIds: normalizedScopeId ? [normalizedScopeId] : []
+  }).runtimeConfig;
+  const scopeOptions = {
+    ...options.contextId ? { contextId: options.contextId } : {},
+    ...options.contextOutputKey ? { contextOutputKey: options.contextOutputKey } : {},
+    visibility
+  };
+  return {
+    config: (0, import_runtime_config.getRuntimeConfigScope)(runtimeConfig, normalizedScopeId, scopeOptions),
+    fileName: getFileName(options),
+    scopeId: normalizedScopeId,
+    varDir,
+    visibility,
+    ...options.contextId ? { contextId: options.contextId } : {}
+  };
+}
+function validateRuntimeConfigScopes(varDir, targets, options = {}) {
+  const schemaFileName = getSchemaFileName(options);
+  const result = {
+    fileName: getFileName(options),
+    skipped: [],
+    validated: [],
+    varDir
+  };
+  for (const target of targets) {
+    const scopeId = target.scopeId.trim();
+    if (!scopeId) continue;
+    const configPath = resolveRuntimeConfigPaths(varDir, scopeId, options).filePath;
+    const schemaPath = target.cwd ? import_node_path.default.resolve(target.cwd, schemaFileName) : void 0;
+    if (!target.cwd || !schemaPath) {
+      result.skipped.push({ configPath, reason: "missing-scope-dir", scopeId });
+      continue;
+    }
+    if (!(0, import_node_fs.existsSync)(configPath)) {
+      result.skipped.push({ configPath, reason: "missing-config", schemaPath, scopeId });
+      continue;
+    }
+    if (!(0, import_node_fs.existsSync)(schemaPath)) {
+      result.skipped.push({ configPath, reason: "missing-schema", schemaPath, scopeId });
+      continue;
+    }
+    result.validated.push({ configPath, schemaPath, scopeId });
+  }
+  validateRuntimeConfigSchemaTargets(result.validated, {
+    ...options.formatError ? { formatError: options.formatError } : {}
+  });
+  return result;
+}
+function validateRuntimeConfigSourceScopes(source, targets, options = {}) {
+  const schemaFileName = getSchemaFileName(options);
+  const filesByScope = /* @__PURE__ */ new Map();
+  const result = {
+    fileName: source.paths[0] ?? "",
+    skipped: [],
+    validated: [],
+    varDir: ""
+  };
+  for (const file of resolveRuntimeConfigSourceFiles(source)) {
+    filesByScope.set(file.scopeId, file.configPath);
+  }
+  for (const target of targets) {
+    const scopeId = target.scopeId.trim();
+    if (!scopeId) continue;
+    const configPath = filesByScope.get(scopeId);
+    const schemaPath = target.cwd ? import_node_path.default.resolve(target.cwd, schemaFileName) : void 0;
+    if (!target.cwd || !schemaPath) {
+      result.skipped.push({
+        ...configPath ? { configPath } : {},
+        reason: "missing-scope-dir",
+        scopeId
+      });
+      continue;
+    }
+    if (!configPath) {
+      result.skipped.push({ reason: "missing-config", schemaPath, scopeId });
+      continue;
+    }
+    if (!(0, import_node_fs.existsSync)(schemaPath)) {
+      result.skipped.push({ configPath, reason: "missing-schema", schemaPath, scopeId });
+      continue;
+    }
+    result.validated.push({ configPath, schemaPath, scopeId });
+  }
+  validateRuntimeConfigSchemaTargets(result.validated, {
+    ...options.formatError ? { formatError: options.formatError } : {}
+  });
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectRuntimeConfigFragmentFiles,
+  ensureParentDir,
+  getRuntimeConfigScopeView,
+  getRuntimeConfigValue,
+  listRuntimeConfigFragments,
+  listRuntimeConfigScopeFiles,
+  loadRuntimeConfigEnvVars,
+  loadRuntimeConfigFragment,
+  loadRuntimeConfigShellAssignments,
+  loadRuntimeConfigSourceTree,
+  loadRuntimeConfigTree,
+  parseRuntimeConfigFragmentFiles,
+  projectRuntimeConfigTree,
+  readJsonFile,
+  readRequiredJsonFile,
+  readRuntimeConfigScopeJson,
+  readTextFile,
+  resolveRuntimeConfigFilePath,
+  resolveRuntimeConfigPaths,
+  resolveRuntimeConfigPublicFilePath,
+  resolveRuntimeConfigPublicRootPath,
+  resolveRuntimeConfigScopeFilePath,
+  resolveRuntimeConfigSource,
+  resolveRuntimeConfigSourceFiles,
+  resolveRuntimeConfigSourcePublicRootPath,
+  showRuntimeConfigFragment,
+  validateRuntimeConfigSchemaTargets,
+  validateRuntimeConfigScopes,
+  validateRuntimeConfigSourceScopes,
+  writeJsonFile,
+  writeRuntimeConfigFragment,
+  writeRuntimeConfigScopeJson,
+  writeTextFile
+});