@ai-setting/roy-agent-core 1.4.12 → 1.4.13

package/dist/config/index.js

@@ -1,1670 +0,0 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __legacyDecorateClassTS = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1;i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// packages/core/src/env/hook/types.ts
-function createHook(meta, fn) {
-  return {
-    ...meta,
-    execute: fn
-  };
-}
-function createPriorityHook(name, fn, priority) {
-  return createHook({ name, priority }, fn);
-}
-// packages/core/src/env/hook/hook-manager.ts
-class HookManager {
-  _hooks = new Map;
-  componentName;
-  componentVersion;
-  defaultPriority;
-  constructor(options = {}) {
-    this.componentName = options.componentName ?? "unknown";
-    this.componentVersion = options.componentVersion ?? "0.0.0";
-    this.defaultPriority = options.defaultPriority ?? 0;
-  }
-  register(hookPoint, hook) {
-    const hooks = this.getOrCreateHooks(hookPoint);
-    hooks.push(hook);
-  }
-  registerMany(hookPoint, hooks) {
-    const hookList = this.getOrCreateHooks(hookPoint);
-    hookList.push(...hooks);
-  }
-  unregister(hookPoint, name) {
-    const hooks = this._hooks.get(hookPoint);
-    if (!hooks)
-      return false;
-    const index = hooks.findIndex((h) => h.name === name);
-    if (index === -1)
-      return false;
-    hooks.splice(index, 1);
-    return true;
-  }
-  unregisterAll(hookPoint) {
-    this._hooks.delete(hookPoint);
-  }
-  async execute(hookPoint, data, metadata = {}) {
-    const hooks = this._hooks.get(hookPoint);
-    if (!hooks || hooks.length === 0)
-      return;
-    const sortedHooks = this.sortHooks(hooks);
-    const ctx = this.createContext(hookPoint, data, metadata, "before");
-    for (const hook of sortedHooks) {
-      await this.safeExecute(hook, ctx);
-    }
-  }
-  async executeAndCollect(hookPoint, data, metadata = {}) {
-    const hooks = this._hooks.get(hookPoint);
-    if (!hooks || hooks.length === 0)
-      return [];
-    const sortedHooks = this.sortHooks(hooks);
-    const ctx = this.createContext(hookPoint, data, metadata, "before");
-    const results = [];
-    for (const hook of sortedHooks) {
-      const result = await this.safeExecuteAndReturn(hook, ctx);
-      if (result !== undefined) {
-        results.push(result);
-      }
-    }
-    return results;
-  }
-  count(hookPoint) {
-    return this._hooks.get(hookPoint)?.length ?? 0;
-  }
-  clear() {
-    this._hooks.clear();
-  }
-  getHookPoints() {
-    return Array.from(this._hooks.keys());
-  }
-  hasHooks(hookPoint) {
-    return this.count(hookPoint) > 0;
-  }
-  setComponentInfo(name, version) {
-    this.componentName = name;
-    this.componentVersion = version;
-  }
-  get hooks() {
-    return this._hooks;
-  }
-  async executeWithIntervention(hookPoint, data, metadata = {}) {
-    const hooks = this._hooks.get(hookPoint);
-    if (!hooks || hooks.length === 0) {
-      return { stopped: false, results: [] };
-    }
-    const sortedHooks = this.sortHooks(hooks);
-    const ctx = this.createContext(hookPoint, data, metadata, "before");
-    const results = [];
-    let stopped = false;
-    let action;
-    for (const hook of sortedHooks) {
-      if (stopped)
-        break;
-      const result = await this.safeExecuteAndReturn(hook, ctx);
-      results.push(result);
-      if (result && typeof result === "object" && "stopped" in result) {
-        const hookResult = result;
-        if (hookResult.stopped) {
-          stopped = true;
-          action = hookResult.action;
-        }
-      }
-    }
-    return { stopped, action, results };
-  }
-  getOrCreateHooks(hookPoint) {
-    let hooks = this._hooks.get(hookPoint);
-    if (!hooks) {
-      hooks = [];
-      this._hooks.set(hookPoint, hooks);
-    }
-    return hooks;
-  }
-  sortHooks(hooks) {
-    return [...hooks].sort((a, b) => {
-      const priorityA = a.priority ?? this.defaultPriority;
-      const priorityB = b.priority ?? this.defaultPriority;
-      return priorityA - priorityB;
-    });
-  }
-  createContext(hookPoint, data, metadata, phase) {
-    return {
-      component: {
-        name: this.componentName,
-        version: this.componentVersion
-      },
-      data,
-      metadata,
-      phase,
-      hookPoint
-    };
-  }
-  async safeExecute(hook, ctx) {
-    try {
-      await hook.execute(ctx);
-    } catch (error) {
-      console.error(`Hook "${hook.name}" failed:`, error);
-    }
-  }
-  async safeExecuteAndReturn(hook, ctx) {
-    try {
-      return await hook.execute(ctx);
-    } catch (error) {
-      console.error(`Hook "${hook.name}" failed:`, error);
-      return;
-    }
-  }
-}
-// packages/core/src/env/hook/global-hook-manager.ts
-var globalHookManager = new HookManager;
-var AgentHookPoints = {
-  BEFORE_START: "agent:before.start",
-  BEFORE_LLM: "agent:before.llm",
-  AFTER_LLM: "agent:after.llm",
-  BEFORE_TOOL: "agent:before.tool",
-  AFTER_TOOL: "agent:after.tool",
-  ON_ITERATION: "agent:on.iteration",
-  ON_THRESHOLD: "agent:on.threshold",
-  AFTER_COMPLETE: "agent:after.complete",
-  ON_ERROR: "agent:on.error"
-};
-var LLMHookPoints = {
-  BEFORE_INVOKE: "llm:before.invoke",
-  AFTER_INVOKE: "llm:after.invoke",
-  ON_STREAM: "llm:on.stream"
-};
-var ToolHookPoints = {
-  BEFORE_EXECUTE: "tool:before.execute",
-  AFTER_EXECUTE: "tool:after.execute",
-  BEFORE_REGISTER: "tool:before.register",
-  AFTER_REGISTER: "tool:after.register",
-  ON_ERROR: "tool:on.error"
-};
-var hookPointAliases = {
-  "before.tool": "tool:before.execute",
-  "after.tool": "tool:after.execute",
-  "llm.before-invoke": "llm:before.invoke",
-  "llm.after-invoke": "llm:after.invoke",
-  "llm.stream": "llm:on.stream"
-};
-function setupAliasHooks() {
-  const originalRegister = globalHookManager.register.bind(globalHookManager);
-  globalHookManager.register = function(hookPoint, hook) {
-    originalRegister(hookPoint, hook);
-    const alias = hookPointAliases[hookPoint];
-    if (alias) {
-      originalRegister(alias, hook);
-    }
-  };
-}
-setupAliasHooks();
-async function executeAgentHook(hookPoint, data, metadata = {}) {
-  await globalHookManager.execute(hookPoint, data, metadata);
-}
-async function executeAgentHookWithIntervention(hookPoint, data, metadata = {}) {
-  return globalHookManager.executeWithIntervention(hookPoint, data, metadata);
-}
-async function executeLLMHook(hookPoint, data, metadata = {}) {
-  await globalHookManager.execute(hookPoint, data, metadata);
-}
-async function executeToolHook(hookPoint, data, metadata = {}) {
-  await globalHookManager.execute(hookPoint, data, metadata);
-}
-// packages/core/src/env/component.ts
-class BaseComponent {
-  _status = "created";
-  _enabled = true;
-  env;
-  hookManager;
-  constructor() {
-    this.hookManager = new HookManager;
-  }
-  getStatus() {
-    return this._status;
-  }
-  getConfig() {
-    return {
-      name: this.name,
-      version: this.version,
-      enabled: this._enabled,
-      env: this.env
-    };
-  }
-  isEnvInitialized() {
-    return this._status !== "created";
-  }
-  setStatus(status) {
-    this._status = status;
-  }
-  getEnv() {
-    return this.env;
-  }
-  async init(config) {
-    if (config?.env) {
-      this.env = config.env;
-    }
-    this.setStatus("initializing");
-    try {
-      if (config?.name)
-        Object.defineProperty(this, "name", { value: config.name, writable: false });
-      if (config?.version)
-        Object.defineProperty(this, "version", { value: config.version, writable: false });
-    } catch {}
-    if (config?.enabled !== undefined)
-      this._enabled = config.enabled;
-    this.hookManager.setComponentInfo(this.name, this.version);
-    await this.onInit();
-    this.setStatus("running");
-  }
-  async start() {
-    if (this._started)
-      return;
-    this._started = true;
-    await this.onStart();
-    this.setStatus("running");
-  }
-  async stop() {
-    this.setStatus("stopping");
-    this.hookManager.clear();
-    await this.onStop();
-    this.setStatus("stopped");
-  }
-  async onInit() {}
-  async onStart() {}
-  async onStop() {}
-  registerHook(hookPoint, hook) {
-    this.hookManager.register(hookPoint, hook);
-  }
-  addHook(hookPoint, name, fn, priority) {
-    this.hookManager.register(hookPoint, createHook({ name, priority }, fn));
-  }
-  removeHook(hookPoint, name) {
-    return this.hookManager.unregister(hookPoint, name);
-  }
-  async executeHooks(hookPoint, data, metadata) {
-    await this.hookManager.execute(hookPoint, data, metadata);
-  }
-  getConfigComponent() {
-    return this.env?.getComponent("config");
-  }
-  getRuntimeConfig(key, defaultValue) {
-    const configComponent = this.getConfigComponent();
-    if (configComponent) {
-      const value = configComponent.get(key);
-      if (value !== undefined) {
-        return value;
-      }
-    }
-    return defaultValue;
-  }
-}
-
-// packages/core/src/env/paths.ts
-import os from "os";
-import path from "path";
-var APP_NAME = "roy-agent";
-function getXdgBase() {
-  const home = os.homedir();
-  try {
-    const xdg = __require("xdg-basedir");
-    return {
-      config: xdg.xdgConfig || path.join(home, ".config"),
-      state: xdg.xdgState || path.join(home, ".local", "state"),
-      data: xdg.xdgData || path.join(home, ".local", "share"),
-      cache: xdg.xdgCache || path.join(home, ".cache")
-    };
-  } catch {
-    return {
-      config: path.join(home, ".config"),
-      state: path.join(home, ".local", "state"),
-      data: path.join(home, ".local", "share"),
-      cache: path.join(home, ".cache")
-    };
-  }
-}
-function computeXDGPaths() {
-  const home = os.homedir();
-  const xdg = getXdgBase();
-  return {
-    home,
-    config: path.join(xdg.config, APP_NAME),
-    state: path.join(xdg.state, APP_NAME),
-    data: path.join(xdg.data, APP_NAME),
-    cache: path.join(xdg.cache, APP_NAME)
-  };
-}
-
-class XDGPathsCalculator {
-  _paths;
-  get paths() {
-    if (!this._paths) {
-      this._paths = computeXDGPaths();
-    }
-    return this._paths;
-  }
-  getPath(type) {
-    return this.paths[type];
-  }
-  getComponentPath(base, subPath) {
-    return path.join(this.paths[base], subPath);
-  }
-  reset() {
-    this._paths = undefined;
-  }
-}
-var XDG_PATHS = new XDGPathsCalculator;
-function getXDGPaths() {
-  return XDG_PATHS.paths;
-}
-function getXDGPath(type) {
-  return XDG_PATHS.getPath(type);
-}
-
-// packages/core/src/config/protocol-resolver.ts
-var PROTOCOL_PATTERN = /^\$\{([^:]+):\/\/([^:#]+)(?:#([^:-]+))?(?::-(.*))?\}$/;
-
-class ProtocolResolver {
-  _xdgDataHome;
-  readFileFn;
-  constructor(options = {}) {
-    this._xdgDataHome = options.xdgDataHome ?? ProtocolResolver.getDefaultXDGDataHome();
-    if (options.readFileFn) {
-      this.readFileFn = options.readFileFn;
-    } else {
-      const fsSync = __require("fs");
-      this.readFileFn = (path2) => fsSync.readFileSync(path2, "utf-8");
-    }
-  }
-  get xdgDataHome() {
-    return this._xdgDataHome;
-  }
-  set xdgDataHome(value) {
-    this._xdgDataHome = value;
-  }
-  static getDefaultXDGDataHome() {
-    return process.env.XDG_DATA_HOME ?? `${process.env.HOME ?? "~"}/.local/share`;
-  }
-  parse(ref) {
-    const match = ref.match(PROTOCOL_PATTERN);
-    if (!match)
-      return null;
-    const [, protocol, path2, key, defaultValue] = match;
-    if (!["file", "env"].includes(protocol))
-      return null;
-    return {
-      protocol,
-      path: path2,
-      key: key ?? "",
-      defaultValue,
-      raw: ref
-    };
-  }
-  isProtocolRef(value) {
-    return PROTOCOL_PATTERN.test(value);
-  }
-  resolve(ref) {
-    const parsed = this.parse(ref);
-    if (!parsed)
-      return null;
-    const value = this.resolveInternal(parsed);
-    if (parsed.protocol === "file" && value === undefined) {
-      return null;
-    }
-    if (value === undefined && parsed.protocol === "env" && parsed.defaultValue === undefined) {
-      return null;
-    }
-    if (value === undefined && parsed.defaultValue !== undefined) {
-      return {
-        value: parsed.defaultValue,
-        source: parsed.protocol
-      };
-    }
-    return {
-      value,
-      source: parsed.protocol
-    };
-  }
-  resolveFileRef(filePath, key) {
-    const resolvedPath = this.resolvePath(filePath);
-    try {
-      const content = this.readFileFn(resolvedPath);
-      let data;
-      try {
-        data = JSON.parse(content);
-      } catch {
-        return content;
-      }
-      return this.getNestedValue(data, key);
-    } catch {
-      return;
-    }
-  }
-  resolveInternal(ref) {
-    switch (ref.protocol) {
-      case "env":
-        return process.env[ref.path];
-      case "file":
-        return this.resolveFileRef(ref.path, ref.key);
-    }
-  }
-  resolvePath(filePath) {
-    if (filePath.startsWith("/")) {
-      return filePath;
-    }
-    if (filePath.startsWith("~")) {
-      return filePath.replace("~", process.env.HOME ?? "");
-    }
-    return `${this._xdgDataHome}/${filePath}`;
-  }
-  getNestedValue(obj, key) {
-    if (key === "$" || key === "")
-      return obj;
-    const keys = key.split(".");
-    let current = obj;
-    for (const k of keys) {
-      if (current === null || current === undefined || typeof current !== "object") {
-        return;
-      }
-      current = current[k];
-    }
-    return current;
-  }
-}
-
-// packages/core/src/config/file-source.ts
-import * as fsSync from "fs";
-import * as fsPromises from "fs/promises";
-import path2 from "path";
-
-// packages/core/src/config/config-parser.ts
-import { parse as parseJSONCInternal, ParseErrorCode } from "jsonc-parser";
-function parseJSONC(content) {
-  const errors = [];
-  const result = parseJSONCInternal(content, errors, {
-    allowTrailingComma: true,
-    disallowComments: false
-  });
-  if (errors.length > 0) {
-    const hasOnlyValueExpected = result === undefined && errors.length === 1 && errors[0].error === ParseErrorCode.ValueExpected;
-    if (!hasOnlyValueExpected) {
-      const error = errors[0];
-      const offset = error.offset;
-      const lines = content.substring(0, offset).split(`
-`);
-      const line = lines.length;
-      const col = lines[lines.length - 1].length + 1;
-      const errorMessages = {
-        [ParseErrorCode.UnexpectedEndOfString]: "Unexpected end of string",
-        [ParseErrorCode.InvalidCharacter]: "Invalid character",
-        [ParseErrorCode.PropertyNameExpected]: "Property name expected",
-        [ParseErrorCode.ValueExpected]: "Value expected",
-        [ParseErrorCode.ColonExpected]: "Colon expected",
-        [ParseErrorCode.CommaExpected]: "Comma expected",
-        [ParseErrorCode.CloseBraceExpected]: "Close brace expected",
-        [ParseErrorCode.CloseBracketExpected]: "Close bracket expected",
-        [ParseErrorCode.EndOfFileExpected]: "Unexpected end of input",
-        [ParseErrorCode.InvalidSymbol]: "Invalid symbol"
-      };
-      throw new Error(`JSONC parse error at line ${line}, col ${col}: ${errorMessages[error.error] || "Unknown error"}`);
-    }
-  }
-  if (result === undefined || result === null) {
-    return {};
-  }
-  return result;
-}
-function substituteEnvVars(value) {
-  if (typeof value === "string") {
-    return value.replace(/\$\{([^}]+)\}/g, (match, varExpr) => {
-      const [varName, defaultValue] = varExpr.split(":-");
-      const envValue = process.env[varName.trim()];
-      if (envValue !== undefined) {
-        return envValue;
-      }
-      if (defaultValue !== undefined) {
-        return defaultValue;
-      }
-      return "";
-    });
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => substituteEnvVars(item));
-  }
-  if (value !== null && typeof value === "object") {
-    const result = {};
-    for (const [key, val] of Object.entries(value)) {
-      result[key] = substituteEnvVars(val);
-    }
-    return result;
-  }
-  return value;
-}
-function parseJSONCWithEnv(content) {
-  const parsed = parseJSONC(content);
-  return substituteEnvVars(parsed);
-}
-var PROTOCOL_REF_PATTERN = /^\$\{([^:]+):\/\/[^}]+\}$/;
-var PROTOCOL_REF_WITH_DEFAULT_PATTERN = /^\$\{([^:]+):\/\/([^:#]+)(?:#([^:-]+))?(?::-(.*))?\}$/;
-function isProtocolRefString(value) {
-  return PROTOCOL_REF_PATTERN.test(value);
-}
-function extractDefaultValue(ref) {
-  const match = ref.match(PROTOCOL_REF_WITH_DEFAULT_PATTERN);
-  return match ? match[4] : undefined;
-}
-function substituteProtocolRefs(value, resolver) {
-  if (typeof value === "string") {
-    if (isProtocolRefString(value)) {
-      const result = resolver.resolve(value);
-      if (result !== null) {
-        return result.value;
-      }
-      const defaultValue = extractDefaultValue(value);
-      if (defaultValue !== undefined) {
-        return defaultValue;
-      }
-    }
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => substituteProtocolRefs(item, resolver));
-  }
-  if (value !== null && typeof value === "object") {
-    const result = {};
-    for (const [key, val] of Object.entries(value)) {
-      result[key] = substituteProtocolRefs(val, resolver);
-    }
-    return result;
-  }
-  return value;
-}
-function parseJSONCWithProtocols(content, resolver) {
-  const parsed = parseJSONC(content);
-  const withProtocols = substituteProtocolRefs(parsed, resolver);
-  return substituteEnvVars(withProtocols);
-}
-
-// packages/core/src/config/file-source.ts
-class FileSource {
-  name = "file";
-  priority = 10;
-  filePath;
-  data = {};
-  watchers = new Set;
-  watcherHandle;
-  debounceMs;
-  pendingWrite;
-  lastFileContent = "";
-  resolver;
-  optional = false;
-  watchEnabled = true;
-  constructor(options, resolver) {
-    if (typeof options === "string") {
-      this.filePath = options;
-      this.debounceMs = 100;
-      this.resolver = resolver;
-      this.optional = true;
-    } else {
-      this.filePath = options.filePath;
-      this.debounceMs = options.debounceMs ?? 100;
-      this.resolver = options.resolver ?? resolver;
-      this.optional = options.optional ?? true;
-      this.watchEnabled = options.watch ?? true;
-    }
-    this.initSync();
-  }
-  initSync() {
-    try {
-      if (fsSync.existsSync(this.filePath)) {
-        const content = fsSync.readFileSync(this.filePath, "utf-8");
-        if (this.resolver) {
-          this.data = parseJSONCWithProtocols(content, this.resolver);
-        } else {
-          this.data = parseJSONCWithEnv(content);
-        }
-        this.lastFileContent = content;
-      } else {
-        if (this.optional) {
-          this.data = {};
-          this.lastFileContent = "{}";
-        } else {
-          throw new Error(`Config file not found: ${this.filePath}`);
-        }
-      }
-    } catch (error) {
-      if (this.optional) {
-        this.data = {};
-        this.lastFileContent = "{}";
-      } else {
-        throw error;
-      }
-    }
-  }
-  async ensureInit() {
-    if (this.lastFileContent === "" && !fsSync.existsSync(this.filePath)) {
-      this.initSync();
-    }
-  }
-  getNestedValue(obj, key) {
-    const keys = key.split(".");
-    let current = obj;
-    for (const k of keys) {
-      if (current === null || current === undefined || typeof current !== "object") {
-        return;
-      }
-      current = current[k];
-    }
-    return current;
-  }
-  setNestedValue(obj, key, value) {
-    const keys = key.split(".");
-    let current = obj;
-    for (let i = 0;i < keys.length - 1; i++) {
-      const k = keys[i];
-      if (!(k in current) || typeof current[k] !== "object" || current[k] === null) {
-        current[k] = {};
-      }
-      current = current[k];
-    }
-    current[keys[keys.length - 1]] = value;
-  }
-  deleteNestedValue(obj, key) {
-    const keys = key.split(".");
-    let current = obj;
-    for (let i = 0;i < keys.length - 1; i++) {
-      const k = keys[i];
-      if (!(k in current) || typeof current[k] !== "object" || current[k] === null) {
-        return false;
-      }
-      current = current[k];
-    }
-    const lastKey = keys[keys.length - 1];
-    if (lastKey in current) {
-      delete current[lastKey];
-      return true;
-    }
-    return false;
-  }
-  flattenObject(obj, prefix = "") {
-    if (obj === null || obj === undefined) {
-      return [];
-    }
-    if (typeof obj !== "object") {
-      return prefix ? [{ key: prefix, value: obj }] : [];
-    }
-    if (Array.isArray(obj)) {
-      return prefix ? [{ key: prefix, value: obj }] : [];
-    }
-    const result = [];
-    const entries = Object.entries(obj);
-    for (const [k, v] of entries) {
-      const newKey = prefix ? `${prefix}.${k}` : k;
-      if (v !== null && typeof v === "object" && !Array.isArray(v)) {
-        result.push(...this.flattenObject(v, newKey));
-      } else {
-        result.push({ key: newKey, value: v });
-      }
-    }
-    return result;
-  }
-  read(key) {
-    return this.getNestedValue(this.data, key);
-  }
-  async readAsync(key) {
-    await this.ensureInit();
-    return this.getNestedValue(this.data, key);
-  }
-  write(key, value) {
-    const oldValue = this.getNestedValue(this.data, key);
-    this.setNestedValue(this.data, key, value);
-    const event = {
-      type: oldValue === undefined ? "add" : "change",
-      key,
-      oldValue,
-      newValue: value,
-      source: this.name,
-      timestamp: Date.now()
-    };
-    this.notifyWatchers(event);
-    this.scheduleWrite();
-    return true;
-  }
-  scheduleWrite() {
-    if (this.pendingWrite) {
-      clearTimeout(this.pendingWrite);
-    }
-    this.pendingWrite = setTimeout(() => {
-      this.persistToFile();
-    }, this.debounceMs);
-  }
-  persistToFile() {
-    try {
-      const dir = path2.dirname(this.filePath);
-      if (!fsSync.existsSync(dir)) {
-        fsSync.mkdirSync(dir, { recursive: true });
-      }
-      const content = JSON.stringify(this.data, null, 2);
-      fsSync.writeFileSync(this.filePath, content, "utf-8");
-      this.lastFileContent = content;
-    } catch (error) {
-      console.error(`Failed to write config to ${this.filePath}:`, error);
-    }
-  }
-  delete(key) {
-    const oldValue = this.getNestedValue(this.data, key);
-    if (oldValue === undefined) {
-      return false;
-    }
-    this.deleteNestedValue(this.data, key);
-    const event = {
-      type: "delete",
-      key,
-      oldValue,
-      newValue: undefined,
-      source: this.name,
-      timestamp: Date.now()
-    };
-    this.notifyWatchers(event);
-    this.scheduleWrite();
-    return true;
-  }
-  list() {
-    return this.flattenObject(this.data);
-  }
-  async listAsync() {
-    await this.ensureInit();
-    return this.flattenObject(this.data);
-  }
-  watch(callback) {
-    this.watchers.add(callback);
-    if (!this.watchEnabled) {
-      return () => {
-        this.watchers.delete(callback);
-      };
-    }
-    this.ensureWatch();
-    return () => {
-      this.watchers.delete(callback);
-      if (this.watchers.size === 0) {
-        this.stopWatch();
-      }
-    };
-  }
-  async ensureWatch() {
-    if (this.watcherHandle !== undefined) {
-      return;
-    }
-    await this.ensureInit();
-    if (!fsSync.existsSync(this.filePath)) {
-      return;
-    }
-    try {
-      this.watcherHandle = fsSync.watch(this.filePath, async (eventType) => {
-        if (eventType === "change") {
-          await new Promise((r) => setTimeout(r, 50));
-          await this.reloadFromFile();
-        }
-      });
-    } catch (error) {
-      console.error(`Failed to watch file ${this.filePath}:`, error);
-    }
-  }
-  stopWatch() {
-    if (this.watcherHandle) {
-      this.watcherHandle.close();
-      this.watcherHandle = undefined;
-    }
-  }
-  async reloadFromFile() {
-    try {
-      const content = await fsPromises.readFile(this.filePath, "utf-8");
-      if (content === this.lastFileContent) {
-        return;
-      }
-      const newData = parseJSONCWithEnv(content);
-      const oldData = this.data;
-      this.data = newData;
-      this.lastFileContent = content;
-      const oldFlat = this.flattenObject(oldData);
-      const newFlat = this.flattenObject(newData);
-      const oldKeys = new Set(oldFlat.map((e) => e.key));
-      const newKeys = new Set(newFlat.map((e) => e.key));
-      for (const key of oldKeys) {
-        if (!newKeys.has(key)) {
-          this.notifyWatchers({
-            type: "delete",
-            key,
-            oldValue: oldFlat.find((e) => e.key === key)?.value,
-            newValue: undefined,
-            source: this.name,
-            timestamp: Date.now()
-          });
-        }
-      }
-      for (const newEntry of newFlat) {
-        const oldEntry = oldFlat.find((e) => e.key === newEntry.key);
-        if (!oldEntry) {
-          this.notifyWatchers({
-            type: "add",
-            key: newEntry.key,
-            oldValue: undefined,
-            newValue: newEntry.value,
-            source: this.name,
-            timestamp: Date.now()
-          });
-        } else if (oldEntry.value !== newEntry.value) {
-          this.notifyWatchers({
-            type: "change",
-            key: newEntry.key,
-            oldValue: oldEntry.value,
-            newValue: newEntry.value,
-            source: this.name,
-            timestamp: Date.now()
-          });
-        }
-      }
-    } catch (error) {
-      console.error(`Failed to reload config from ${this.filePath}:`, error);
-    }
-  }
-  notifyWatchers(event) {
-    this.watchers.forEach((cb) => cb(event));
-  }
-  async refresh() {
-    await this.reloadFromFile();
-  }
-  async close() {
-    this.stopWatch();
-    if (this.pendingWrite) {
-      clearTimeout(this.pendingWrite);
-      this.pendingWrite = undefined;
-    }
-    this.persistToFile();
-  }
-}
-
-// packages/core/src/config/env-key.ts
-function toEnvKey(key, prefix) {
-  let keyNormalized = key.replace(/[.-]/g, "_");
-  keyNormalized = keyNormalized.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/_+/g, "_").toUpperCase();
-  if (prefix) {
-    const separator = prefix.endsWith("_") ? "" : "_";
-    return `${prefix}${separator}${keyNormalized}`;
-  }
-  return keyNormalized;
-}
-function fromEnvKey(envKey, prefix) {
-  if (!prefix) {
-    return envKey;
-  }
-  if (envKey.startsWith(prefix)) {
-    const afterPrefix = envKey.slice(prefix.length);
-    if (afterPrefix.startsWith("_")) {
-      return afterPrefix.slice(1);
-    }
-    return afterPrefix;
-  }
-  return envKey;
-}
-function envKeyToConfigKey(envKey, prefix, componentName) {
-  const prefixUpper = prefix.toUpperCase();
-  if (!envKey.startsWith(prefixUpper)) {
-    return;
-  }
-  const componentUpperNormalized = componentName.replace(/-/g, "_").toUpperCase();
-  let keyPart = envKey.slice(prefixUpper.length);
-  if (keyPart.startsWith("_")) {
-    keyPart = keyPart.slice(1);
-  }
-  if (!keyPart) {
-    return;
-  }
-  const firstUnderscore = keyPart.indexOf("_");
-  let restPart;
-  if (firstUnderscore === -1) {
-    restPart = keyPart;
-  } else {
-    const firstPart = keyPart.slice(0, firstUnderscore);
-    const remaining = keyPart.slice(firstUnderscore + 1);
-    if (firstPart === componentUpperNormalized) {
-      restPart = remaining;
-    } else {
-      restPart = keyPart;
-    }
-  }
-  if (!restPart) {
-    return;
-  }
-  const restPartConverted = restPart.replace(/_/g, ".");
-  return `${componentName}.${restPartConverted.toLowerCase()}`;
-}
-
-// packages/core/src/config/env-source.ts
-class EnvSource {
-  name = "env";
-  priority = 20;
-  prefix;
-  transform;
-  pollInterval;
-  watchers = new Set;
-  pollTimer;
-  lastValues = new Map;
-  watchEnabled = true;
-  constructor(options = {}) {
-    this.prefix = options.prefix ?? "";
-    this.transform = options.transform;
-    this.pollInterval = options.pollInterval;
-    this.watchEnabled = options.watch ?? true;
-  }
-  getEnvKey(key) {
-    return toEnvKey(key, this.prefix);
-  }
-  getInternalKey(envKey) {
-    return fromEnvKey(envKey, this.prefix);
-  }
-  read(key) {
-    const envKey = this.getEnvKey(key);
-    const value = process.env[envKey];
-    if (value === undefined) {
-      return;
-    }
-    if (this.transform) {
-      return this.transform(value, key);
-    }
-    return value;
-  }
-  write(key, value) {
-    const envKey = this.getEnvKey(key);
-    const oldValue = process.env[envKey];
-    const stringValue = String(value);
-    process.env[envKey] = stringValue;
-    const event = {
-      type: oldValue === undefined ? "add" : "change",
-      key,
-      oldValue: oldValue !== undefined ? this.transformValue(oldValue, key) : undefined,
-      newValue: this.transformValue(stringValue, key),
-      source: this.name,
-      timestamp: Date.now()
-    };
-    this.notifyWatchers(event);
-    return true;
-  }
-  delete(key) {
-    const envKey = this.getEnvKey(key);
-    const oldValue = process.env[envKey];
-    if (oldValue === undefined) {
-      return false;
-    }
-    delete process.env[envKey];
-    const event = {
-      type: "delete",
-      key,
-      oldValue: this.transformValue(oldValue, key),
-      newValue: undefined,
-      source: this.name,
-      timestamp: Date.now()
-    };
-    this.notifyWatchers(event);
-    return true;
-  }
-  list() {
-    const result = [];
-    const prefix = this.prefix.toUpperCase();
-    for (const envKey of Object.keys(process.env)) {
-      if (prefix && !envKey.startsWith(prefix)) {
-        continue;
-      }
-      const key = this.getInternalKey(envKey);
-      const value = process.env[envKey];
-      if (value !== undefined) {
-        result.push({
-          key,
-          value: this.transformValue(value, key)
-        });
-      }
-    }
-    return result;
-  }
-  watch(callback) {
-    this.watchers.add(callback);
-    if (!this.watchEnabled) {
-      return () => {
-        this.watchers.delete(callback);
-      };
-    }
-    this.ensurePolling();
-    this.recordCurrentValues();
-    return () => {
-      this.watchers.delete(callback);
-      if (this.watchers.size === 0) {
-        this.stopPolling();
-      }
-    };
-  }
-  ensurePolling() {
-    if (this.pollTimer !== undefined) {
-      return;
-    }
-    const interval = this.pollInterval ?? 1000;
-    this.pollTimer = setInterval(() => {
-      this.checkForChanges();
-    }, interval);
-  }
-  stopPolling() {
-    if (this.pollTimer) {
-      clearInterval(this.pollTimer);
-      this.pollTimer = undefined;
-    }
-  }
-  recordCurrentValues() {
-    this.lastValues.clear();
-    const entries = this.list();
-    for (const entry of entries) {
-      const envKey = this.getEnvKey(entry.key);
-      const value = process.env[envKey];
-      if (value !== undefined) {
-        this.lastValues.set(envKey, value);
-      }
-    }
-  }
-  checkForChanges() {
-    const currentEntries = this.list();
-    const currentValues = new Map;
-    for (const entry of currentEntries) {
-      const envKey = this.getEnvKey(entry.key);
-      const value = process.env[envKey];
-      if (value !== undefined) {
-        currentValues.set(envKey, value);
-      }
-    }
-    for (const [envKey, oldValue] of this.lastValues.entries()) {
-      if (!currentValues.has(envKey)) {
-        const key = this.getInternalKey(envKey);
-        this.notifyWatchers({
-          type: "delete",
-          key,
-          oldValue: this.transformValue(oldValue, key),
-          newValue: undefined,
-          source: this.name,
-          timestamp: Date.now()
-        });
-      }
-    }
-    for (const [envKey, newValue] of currentValues.entries()) {
-      const key = this.getInternalKey(envKey);
-      const oldValue = this.lastValues.get(envKey);
-      if (oldValue === undefined) {
-        this.notifyWatchers({
-          type: "add",
-          key,
-          oldValue: undefined,
-          newValue: this.transformValue(newValue, key),
-          source: this.name,
-          timestamp: Date.now()
-        });
-      } else if (oldValue !== newValue) {
-        this.notifyWatchers({
-          type: "change",
-          key,
-          oldValue: this.transformValue(oldValue, key),
-          newValue: this.transformValue(newValue, key),
-          source: this.name,
-          timestamp: Date.now()
-        });
-      }
-    }
-    this.lastValues = currentValues;
-  }
-  transformValue(value, key) {
-    if (this.transform) {
-      return this.transform(value, key);
-    }
-    return value;
-  }
-  notifyWatchers(event) {
-    this.watchers.forEach((cb) => cb(event));
-  }
-  close() {
-    this.stopPolling();
-    this.watchers.clear();
-  }
-}
-
-// packages/core/src/config/config-component.ts
-import * as os2 from "os";
-import * as path3 from "path";
-
-class ConfigSourceNotFoundError extends Error {
-  constructor(sourceType, path4) {
-    const message = path4 ? `Config source not found: ${sourceType} at ${path4}` : `Config source not found: ${sourceType}`;
-    super(message);
-    this.name = "ConfigSourceNotFoundError";
-  }
-}
-
-class ConfigFileNotFoundError extends Error {
-  constructor(filePath) {
-    super(`Config file not found: ${filePath}`);
-    this.name = "ConfigFileNotFoundError";
-  }
-}
-
-class MemorySource {
-  name = "memory";
-  priority = 0;
-  store = new Map;
-  watchers = new Set;
-  read(key) {
-    return this.store.get(key)?.value;
-  }
-  write(key, value) {
-    const oldEntry = this.store.get(key);
-    const entry = {
-      value,
-      timestamp: Date.now(),
-      version: (oldEntry?.version ?? 0) + 1
-    };
-    this.store.set(key, entry);
-    this.notifyWatchers({
-      type: oldEntry ? "change" : "add",
-      key,
-      oldValue: oldEntry?.value,
-      newValue: value,
-      source: "memory",
-      timestamp: entry.timestamp
-    });
-    return true;
-  }
-  delete(key) {
-    const entry = this.store.get(key);
-    if (!entry)
-      return false;
-    this.store.delete(key);
-    this.notifyWatchers({
-      type: "delete",
-      key,
-      oldValue: entry.value,
-      newValue: undefined,
-      source: "memory",
-      timestamp: Date.now()
-    });
-    return true;
-  }
-  list() {
-    return Array.from(this.store.entries()).map(([key, entry]) => ({
-      key,
-      value: entry.value
-    }));
-  }
-  watch(callback) {
-    this.watchers.add(callback);
-    return () => this.watchers.delete(callback);
-  }
-  notifyWatchers(event) {
-    this.watchers.forEach((cb) => cb(event));
-  }
-}
-
-class AsyncPersistQueue {
-  options;
-  queue = new Map;
-  timer;
-  paused = false;
-  constructor(options) {
-    this.options = options;
-  }
-  add(key, value) {
-    this.queue.set(key, { key, value, timestamp: Date.now() });
-    this.scheduleFlush();
-  }
-  scheduleFlush() {
-    if (this.paused || this.timer)
-      return;
-    this.timer = setTimeout(async () => {
-      this.timer = undefined;
-      await this.flush();
-    }, this.options.debounceMs);
-  }
-  async flush() {
-    if (this.queue.size === 0)
-      return;
-    const entries = Array.from(this.queue.values());
-    this.queue.clear();
-    try {
-      await this.options.persistFn(entries);
-    } catch (error) {
-      console.error("Failed to persist config:", error);
-    }
-  }
-  clear() {
-    this.queue.clear();
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = undefined;
-    }
-  }
-  size() {
-    return this.queue.size;
-  }
-  pause() {
-    this.paused = true;
-  }
-  resume() {
-    this.paused = false;
-    if (this.queue.size > 0) {
-      this.scheduleFlush();
-    }
-  }
-}
-
-class ConfigComponent extends BaseComponent {
-  name = "config";
-  version = "1.0.0";
-  memorySource = new MemorySource;
-  sources = [this.memorySource];
-  componentSchemas = new Map;
-  componentPaths = new Map;
-  watchers = new Map;
-  sourceUnwatchFns = new Map;
-  persistQueue;
-  persistFile;
-  keyRegistry = new Map;
-  componentRegistrations = new Map;
-  protocolResolver;
-  __xdgDataHome;
-  pendingSources = [];
-  sourceKeys = new Map;
-  getXdgDataHome() {
-    return this.__xdgDataHome ?? process.env.XDG_DATA_HOME ?? path3.join(os2.homedir(), ".local", "share");
-  }
-  setXdgDataHome(path4) {
-    this.__xdgDataHome = path4;
-    if (this.protocolResolver) {
-      this.protocolResolver.xdgDataHome = path4;
-    }
-  }
-  constructor(options = {}) {
-    super();
-    this.persistFile = options.persistFile;
-    this.persistQueue = new AsyncPersistQueue({
-      debounceMs: options.debounceMs ?? 300,
-      persistFn: this.persistToFile.bind(this)
-    });
-    this.protocolResolver = new ProtocolResolver;
-  }
-  register(schema) {
-    this.componentSchemas.set(schema.name, schema);
-    if (schema.paths) {
-      this.componentPaths.set(schema.name, schema.paths);
-    }
-    for (const [key, value] of Object.entries(schema.defaults)) {
-      const fullKey = `${schema.name}.${key}`;
-      if (this.memorySource.read(fullKey) === undefined) {
-        this.memorySource.write(fullKey, value);
-      }
-    }
-  }
-  unregister(name) {
-    this.componentSchemas.delete(name);
-    this.componentPaths.delete(name);
-    return true;
-  }
-  isRegistered(name) {
-    return this.componentSchemas.has(name);
-  }
-  listComponents() {
-    return Array.from(this.componentSchemas.keys());
-  }
-  get(key) {
-    const memoryValue = this.memorySource.read(key);
-    if (memoryValue !== undefined) {
-      return memoryValue;
-    }
-    if (key.includes(".")) {
-      const parts = key.split(".");
-      for (let i = parts.length - 1;i >= 1; i--) {
-        const componentParts = parts.slice(0, i);
-        const component = componentParts.join(".");
-        const restParts = parts.slice(i);
-        const restKey = restParts.join(".");
-        const componentValue = this.memorySource.read(component);
-        if (typeof componentValue === "object" && componentValue !== null) {
-          const nestedValue = this.getNestedValue(componentValue, restKey);
-          if (nestedValue !== undefined) {
-            return nestedValue;
-          }
-        }
-      }
-    }
-    return;
-  }
-  getMany(keys) {
-    const result = {};
-    for (const key of keys) {
-      result[key] = this.get(key);
-    }
-    return result;
-  }
-  async set(key, value) {
-    const oldValue = this.get(key);
-    this.memorySource.write(key, value);
-    const event = {
-      component: key.split(".")[0],
-      key,
-      oldValue,
-      newValue: value,
-      persisted: false,
-      timestamp: Date.now()
-    };
-    this.notifyWatchers(key, event);
-    this.persistQueue.add(key, value);
-  }
-  async setMany(config) {
-    for (const [key, value] of Object.entries(config)) {
-      await this.set(key, value);
-    }
-  }
-  getPath(component, subPath) {
-    const paths = this.componentPaths.get(component);
-    if (!paths) {
-      throw new Error(`Component not registered: ${component}`);
-    }
-    if (subPath && paths[subPath]) {
-      const { base: base2, subPath: relativePath2 } = paths[subPath];
-      return XDG_PATHS.getComponentPath(base2, relativePath2);
-    }
-    const firstKey = Object.keys(paths)[0];
-    if (!firstKey) {
-      throw new Error(`No paths registered for component: ${component}`);
-    }
-    const { base, subPath: relativePath } = paths[firstKey];
-    return XDG_PATHS.getComponentPath(base, relativePath);
-  }
-  async save(key) {
-    await this.persistQueue.flush();
-  }
-  async reset(key) {
-    const [component, ...rest] = key.split(".");
-    const schema = this.componentSchemas.get(component);
-    if (!schema)
-      return;
-    const partialKey = rest.join(".");
-    const defaultValue = schema.defaults[partialKey] ?? schema.defaults[key];
-    if (defaultValue !== undefined) {
-      await this.set(key, defaultValue);
-    }
-  }
-  watch(pattern, callback) {
-    if (!this.watchers.has(pattern)) {
-      this.watchers.set(pattern, new Set);
-    }
-    this.watchers.get(pattern).add(callback);
-    return () => {
-      this.watchers.get(pattern)?.delete(callback);
-    };
-  }
-  addSource(source) {
-    this.sources.push(source);
-    this.sources.sort((a, b) => a.priority - b.priority);
-    if (source.watch) {
-      const callback = (event) => {
-        this.notifyWatchers(event.key, {
-          component: event.key.split(".")[0],
-          key: event.key,
-          oldValue: event.oldValue,
-          newValue: event.newValue,
-          persisted: true,
-          timestamp: event.timestamp
-        });
-      };
-      try {
-        const unwatch = source.watch(callback);
-        const sourceKey = this.getSourceKey(source);
-        this.sourceUnwatchFns.set(sourceKey, unwatch);
-      } catch {}
-    }
-  }
-  getSourceKey(source) {
-    if ("filePath" in source) {
-      return `file:${source.filePath}`;
-    }
-    if ("prefix" in source) {
-      return `env:${source.prefix}`;
-    }
-    return source.name;
-  }
-  removeSource(name) {
-    const index = this.sources.findIndex((s) => s.name === name);
-    if (index > 0) {
-      const source = this.sources[index];
-      const sourceKey = this.getSourceKey(source);
-      const unwatch = this.sourceUnwatchFns.get(sourceKey);
-      if (unwatch) {
-        unwatch();
-        this.sourceUnwatchFns.delete(sourceKey);
-      }
-      this.sources.splice(index, 1);
-      return true;
-    }
-    return false;
-  }
-  unwatchAll() {
-    for (const unwatch of this.sourceUnwatchFns.values()) {
-      unwatch();
-    }
-    this.sourceUnwatchFns.clear();
-  }
-  getSources() {
-    return [...this.sources];
-  }
-  getNestedValue(obj, key) {
-    const keys = key.split(".");
-    let current = obj;
-    for (const k of keys) {
-      if (typeof current !== "object" || current === null)
-        return;
-      current = current[k];
-    }
-    return current;
-  }
-  notifyWatchers(key, event) {
-    const exactWatchers = this.watchers.get(key);
-    exactWatchers?.forEach((cb) => cb(event));
-    const [component] = key.split(".");
-    const wildcardWatchers = this.watchers.get(`${component}.*`);
-    wildcardWatchers?.forEach((cb) => cb(event));
-    const globalWatchers = this.watchers.get("*");
-    globalWatchers?.forEach((cb) => cb(event));
-  }
-  async persistToFile(entries) {
-    if (!this.persistFile)
-      return;
-    console.log(`[ConfigComponent] Persisting ${entries.length} entries to ${this.persistFile}`);
-  }
-  registerSource(registration) {
-    const { type, relativePath, envPrefix } = registration;
-    const sourceKey = type === "file" && relativePath ? `file:${relativePath}` : `${type}:${envPrefix ?? ""}`;
-    if (this.sourceKeys.has(sourceKey)) {
-      return;
-    }
-    this.pendingSources.push(registration);
-    this.sourceKeys.set(sourceKey, true);
-  }
-  createSource(registration) {
-    const { type, relativePath, envPrefix, priority, optional, watch: watch2 } = registration;
-    switch (type) {
-      case "memory": {
-        return this.memorySource;
-      }
-      case "file": {
-        if (!relativePath) {
-          throw new Error("File source requires relativePath");
-        }
-        const isAbsolutePath = path3.isAbsolute(relativePath) || relativePath.startsWith("file://");
-        let filePath;
-        if (isAbsolutePath) {
-          filePath = relativePath.startsWith("file://") ? relativePath.replace(/^file:\/\//, "") : relativePath;
-        } else {
-          if (this.protocolResolver) {
-            this.protocolResolver.xdgDataHome = this.getXdgDataHome();
-          }
-          filePath = path3.join(this.getXdgDataHome(), relativePath);
-        }
-        return new FileSource({
-          filePath,
-          optional: optional ?? false,
-          resolver: this.protocolResolver,
-          watch: watch2
-        });
-      }
-      case "env": {
-        return new EnvSource({
-          prefix: envPrefix ?? "",
-          priority: priority ?? 20,
-          watch: watch2
-        });
-      }
-      default:
-        throw new Error(`Unknown source type: ${type}`);
-    }
-  }
-  ensureSourcesCreated() {
-    for (const pending of this.pendingSources) {
-      const source = this.createSource(pending);
-      this.addSource(source);
-    }
-    this.pendingSources = [];
-  }
-  registerKeys(keys) {
-    for (const keyReg of keys) {
-      if (this.keyRegistry.has(keyReg.key)) {
-        continue;
-      }
-      this.keyRegistry.set(keyReg.key, keyReg);
-      if (keyReg.default !== undefined) {
-        if (this.memorySource.read(keyReg.key) === undefined) {
-          this.memorySource.write(keyReg.key, keyReg.default);
-        }
-      }
-    }
-  }
-  registerComponent(registration) {
-    const { name, sources, keys, defaults } = registration;
-    this.componentRegistrations.set(name, registration);
-    for (const sourceReg of sources) {
-      this.registerSource(sourceReg);
-    }
-    this.registerKeys(keys);
-    if (defaults) {
-      for (const [key, value] of Object.entries(defaults)) {
-        const fullKey = `${name}.${key}`;
-        if (this.memorySource.read(fullKey) === undefined) {
-          this.memorySource.write(fullKey, value);
-        }
-      }
-    }
-  }
-  async load(componentName) {
-    this.ensureSourcesCreated();
-    let keysToLoad;
-    if (componentName) {
-      const registration = this.componentRegistrations.get(componentName);
-      if (!registration) {
-        return;
-      }
-      keysToLoad = registration.keys.map((k) => ({
-        key: k.key,
-        sources: k.sources
-      }));
-    } else {
-      keysToLoad = Array.from(this.keyRegistry.values()).map((k) => ({
-        key: k.key,
-        sources: k.sources
-      }));
-    }
-    const sourcesByType = new Map;
-    for (const source of this.sources) {
-      sourcesByType.set(source.name, source);
-    }
-    for (const { key, sources: sourceTypes } of keysToLoad) {
-      if (this.memorySource.read(key) !== undefined) {
-        continue;
-      }
-      for (const sourceType of sourceTypes) {
-        const source = sourcesByType.get(sourceType);
-        if (!source)
-          continue;
-        const value = source.read(key);
-        if (value !== undefined) {
-          this.memorySource.write(key, value);
-          break;
-        }
-      }
-    }
-  }
-  getRegisteredSources() {
-    this.ensureSourcesCreated();
-    return [...this.sources];
-  }
-}
-export {
-  substituteProtocolRefs,
-  substituteEnvVars,
-  parseJSONCWithProtocols,
-  parseJSONCWithEnv,
-  parseJSONC,
-  MemorySource,
-  FileSource,
-  EnvSource,
-  ConfigSourceNotFoundError,
-  ConfigFileNotFoundError,
-  ConfigComponent
-};