@ai-setting/roy-agent-core 1.5.15-test → 1.5.16-test

package/dist/shared/@ai-setting/roy-agent-core-vn2bc59q.js

@@ -0,0 +1,1205 @@
+import {
+  XDG_PATHS
+} from "./roy-agent-core-qxnbvgwe.js";
+import {
+  fromEnvKey,
+  toEnvKey
+} from "./roy-agent-core-qxhq8ven.js";
+import {
+  BaseComponent
+} from "./roy-agent-core-kkbwepqb.js";
+import {
+  __require
+} from "./roy-agent-core-fs0mn2jk.js";
+
+// 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);
+}
+
+// src/config/file-source.ts
+import * as fsSync from "fs";
+import * as fsPromises from "fs/promises";
+import path from "path";
+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 = path.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();
+  }
+}
+
+// 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();
+  }
+}
+
+// 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 fsSync2 = __require("fs");
+      this.readFileFn = (path2) => fsSync2.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;
+  }
+}
+
+// src/config/config-component.ts
+import * as os from "os";
+import * as path2 from "path";
+
+class ConfigSourceNotFoundError extends Error {
+  constructor(sourceType, path3) {
+    const message = path3 ? `Config source not found: ${sourceType} at ${path3}` : `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 ?? path2.join(os.homedir(), ".local", "share");
+  }
+  setXdgDataHome(path3) {
+    this.__xdgDataHome = path3;
+    if (this.protocolResolver) {
+      this.protocolResolver.xdgDataHome = path3;
+    }
+  }
+  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 = path2.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 = path2.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 { parseJSONC, substituteEnvVars, parseJSONCWithEnv, substituteProtocolRefs, parseJSONCWithProtocols, FileSource, EnvSource, ConfigSourceNotFoundError, ConfigFileNotFoundError, MemorySource, ConfigComponent };