@ai-setting/roy-agent-core 1.3.10 → 1.3.11

package/dist/config/index.js

@@ -0,0 +1,1647 @@
+// @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 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();
+// 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
+};