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

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

@@ -1,1205 +0,0 @@
-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 };