@elizaos/agent 2.0.0-beta.1 → 2.0.11-beta.5

package/config/config.js

@@ -0,0 +1,288 @@
+import fs from "node:fs";
+import path from "node:path";
+import { logger } from "@elizaos/core";
+import { isElizaSettingsDebugEnabled, migrateLegacyRuntimeConfig, sanitizeForSettingsDebug, settingsDebugCloudSummary, } from "@elizaos/shared";
+import JSON5 from "json5";
+import { readConfigEnvSync } from "../api/config-env.js";
+import { syncSolanaPublicKeyEnv } from "../api/wallet-env-sync.js";
+import { isVaultRef } from "../runtime/operations/vault-bridge.js";
+import { collectConfigEnvVars, collectConnectorEnvVars } from "./env-vars.js";
+import { resolveConfigIncludes } from "./includes.js";
+import { normalizeModelMetadataInConfig } from "./model-metadata.js";
+import { resolveConfigPath, resolveStateDir, resolveUserPath, } from "./paths.js";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveConfigWritePath(env = process.env) {
+    const persistPath = env.ELIZA_PERSIST_CONFIG_PATH?.trim();
+    return persistPath ? resolveUserPath(persistPath) : resolveConfigPath();
+}
+function applyConfigEnvToProcessEnv(entries) {
+    for (const [key, value] of Object.entries(entries)) {
+        // Skip unresolved vault sentinels. The boot-time vault hydration
+        // (resolveConfigEnvForProcess + applyCloudConfigToEnv) writes the resolved
+        // plaintext to process.env once at startup. Many services call
+        // loadElizaConfig() again later for unrelated reads; without this guard the
+        // sentinel literal `vault://KEY` would overwrite the real plaintext on
+        // every such call, and downstream `runtime.getSetting()` would hand the
+        // sentinel to consumers like plugin-elizacloud, producing 401s.
+        if (isVaultRef(value))
+            continue;
+        process.env[key] = value;
+    }
+}
+function getConfigEnvString(config, key) {
+    const envConfig = config.env;
+    const nestedVars = envConfig?.vars &&
+        typeof envConfig.vars === "object" &&
+        !Array.isArray(envConfig.vars)
+        ? envConfig.vars
+        : undefined;
+    const value = nestedVars?.[key] ?? envConfig?.[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function mergeConfigRecords(base, overlay) {
+    if (overlay === undefined) {
+        return base;
+    }
+    if (Array.isArray(overlay)) {
+        return overlay.slice();
+    }
+    if (isPlainObject(base) && isPlainObject(overlay)) {
+        const merged = { ...base };
+        for (const [key, value] of Object.entries(overlay)) {
+            merged[key] = mergeConfigRecords(base[key], value);
+        }
+        return merged;
+    }
+    return overlay;
+}
+function readConfigFile(configPath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(configPath, "utf-8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return null;
+        }
+        throw err;
+    }
+    const parsed = JSON5.parse(raw);
+    return resolveConfigIncludes(parsed, configPath);
+}
+export function loadElizaConfig() {
+    const configPath = resolveConfigPath();
+    const persistPath = resolveConfigWritePath();
+    const baseConfig = readConfigFile(configPath);
+    const persistedConfig = persistPath !== configPath ? readConfigFile(persistPath) : null;
+    const resolved = (baseConfig || persistedConfig
+        ? mergeConfigRecords(baseConfig ?? {}, persistedConfig ?? {})
+        : { logging: { level: "error" } });
+    migrateLegacyRuntimeConfig(resolved);
+    normalizeModelMetadataInConfig(resolved);
+    const skillsJsonPath = path.join(resolveStateDir(), "skills.json");
+    if (!fs.existsSync(skillsJsonPath)) {
+        try {
+            const skillsDir = path.dirname(skillsJsonPath);
+            if (!fs.existsSync(skillsDir)) {
+                fs.mkdirSync(skillsDir, { recursive: true });
+            }
+            fs.writeFileSync(skillsJsonPath, JSON.stringify({ extraDirs: [] }, null, 2), "utf-8");
+        }
+        catch (err) {
+            logger.warn(`[eliza] Failed to auto-create ${skillsJsonPath}: ${String(err)}`);
+        }
+    }
+    if (fs.existsSync(skillsJsonPath)) {
+        try {
+            const skillsRaw = fs.readFileSync(skillsJsonPath, "utf-8");
+            const skillsConfig = JSON5.parse(skillsRaw);
+            if (skillsConfig.extraDirs &&
+                Array.isArray(skillsConfig.extraDirs) &&
+                skillsConfig.extraDirs.length > 0) {
+                if (!resolved.skills)
+                    resolved.skills = {};
+                if (!resolved.skills.load)
+                    resolved.skills.load = {};
+                if (!resolved.skills.load.extraDirs) {
+                    resolved.skills.load.extraDirs = [];
+                }
+                const existing = new Set(resolved.skills.load.extraDirs);
+                for (const dir of skillsConfig.extraDirs) {
+                    const loadedDir = resolveUserPath(dir);
+                    if (!existing.has(loadedDir)) {
+                        resolved.skills.load.extraDirs.push(loadedDir);
+                        existing.add(loadedDir);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            logger.warn(`[eliza] Failed to load ${skillsJsonPath}: ${String(err)}`);
+        }
+    }
+    if (!resolved.logging) {
+        resolved.logging = { level: "error" };
+    }
+    else if (!resolved.logging.level) {
+        resolved.logging.level = "error";
+    }
+    const persistedConfigEnv = readConfigEnvSync(resolveStateDir());
+    // SECURITY: Do NOT merge persistedConfigEnv into resolved.env — config.env
+    // is the designated escape hatch for secrets that must NOT be serialized to
+    // eliza.json (e.g. ELIZA_CLOUD_CLIENT_ADDRESS_KEY, WALLET_SOURCE_*).
+    // Merging would create a sensitive-data boundary violation.
+    // Instead, apply directly to process.env (below).
+    const envVars = collectConfigEnvVars(resolved);
+    const connectorEnvVars = collectConnectorEnvVars(resolved);
+    // Saved config is the source of truth for settings edited in the app.
+    // If a key is persisted here, it should override any stale value that
+    // arrived from .env or the parent shell.
+    applyConfigEnvToProcessEnv(envVars);
+    applyConfigEnvToProcessEnv(connectorEnvVars);
+    applyConfigEnvToProcessEnv(persistedConfigEnv);
+    const discordToken = process.env.DISCORD_API_TOKEN?.trim() ||
+        process.env.DISCORD_BOT_TOKEN?.trim();
+    if (discordToken) {
+        process.env.DISCORD_API_TOKEN = discordToken;
+        process.env.DISCORD_BOT_TOKEN = discordToken;
+    }
+    // Keep public-key aliases available when only the private key is configured.
+    syncSolanaPublicKeyEnv(getConfigEnvString(resolved, "SOLANA_PRIVATE_KEY"));
+    if (isElizaSettingsDebugEnabled()) {
+        const cloud = resolved.cloud;
+        logger.debug({
+            path: configPath,
+            persistPath: persistPath !== configPath ? persistPath : undefined,
+            topLevelKeys: Object.keys(resolved).sort(),
+            cloud: settingsDebugCloudSummary(cloud),
+            envVarKeysHydrated: Object.keys({
+                ...persistedConfigEnv,
+                ...envVars,
+                ...connectorEnvVars,
+            }).sort(),
+            snapshot: sanitizeForSettingsDebug(resolved),
+        }, "[eliza][settings][loadElizaConfig]");
+    }
+    return resolved;
+}
+function stripIncludeDirectives(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (Array.isArray(value))
+        return value.map(stripIncludeDirectives);
+    if (typeof value !== "object")
+        return value;
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+        if (key === "$include")
+            continue;
+        result[key] = stripIncludeDirectives(val);
+    }
+    return result;
+}
+function isWalletOsStoreEnabledInConfig(config) {
+    const envConfig = config.env;
+    if (!envConfig || typeof envConfig !== "object" || Array.isArray(envConfig)) {
+        return false;
+    }
+    const raw = envConfig.ELIZA_WALLET_OS_STORE;
+    if (typeof raw !== "string") {
+        return false;
+    }
+    const normalized = raw.trim().toLowerCase();
+    return (normalized === "1" ||
+        normalized === "true" ||
+        normalized === "on" ||
+        normalized === "yes");
+}
+function stripWalletPrivateKeysFromConfig(config) {
+    const envConfig = config.env;
+    if (!envConfig || typeof envConfig !== "object" || Array.isArray(envConfig)) {
+        return;
+    }
+    delete envConfig.EVM_PRIVATE_KEY;
+    delete envConfig.SOLANA_PRIVATE_KEY;
+    const nestedVars = envConfig.vars &&
+        typeof envConfig.vars === "object" &&
+        !Array.isArray(envConfig.vars)
+        ? envConfig.vars
+        : undefined;
+    if (nestedVars) {
+        delete nestedVars.EVM_PRIVATE_KEY;
+        delete nestedVars.SOLANA_PRIVATE_KEY;
+    }
+}
+export function saveElizaConfig(config) {
+    const configPath = resolveConfigWritePath();
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    migrateLegacyRuntimeConfig(config);
+    if (isWalletOsStoreEnabledInConfig(config)) {
+        stripWalletPrivateKeysFromConfig(config);
+    }
+    const sanitized = stripIncludeDirectives(config);
+    if (!sanitized || typeof sanitized !== "object") {
+        throw new Error(`[eliza-config] stripIncludeDirectives returned invalid result: ${typeof sanitized}`);
+    }
+    migrateLegacyRuntimeConfig(sanitized);
+    if (isWalletOsStoreEnabledInConfig(sanitized)) {
+        stripWalletPrivateKeysFromConfig(sanitized);
+    }
+    const content = `${JSON.stringify(sanitized, null, 2)}\n`;
+    // Atomic write: write to a temp file then rename. If the process crashes
+    // during writeFileSync, only the temp file is corrupted — the original
+    // config remains intact. rename() is atomic on POSIX filesystems when
+    // source and destination are on the same filesystem.
+    //
+    // Resolve symlinks so dotfile-managed setups (symlinked config) update
+    // the target file instead of replacing the symlink with a regular file.
+    const realConfigPath = fs.existsSync(configPath)
+        ? fs.realpathSync(configPath)
+        : configPath;
+    const tmpPath = `${realConfigPath}.tmp.${process.pid}`;
+    fs.writeFileSync(tmpPath, content, {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+    fs.renameSync(tmpPath, realConfigPath);
+    // Enforce 600 on every write — writeFileSync's mode only applies on
+    // creation, so files created by older versions retain their original
+    // (potentially world-readable) permissions.
+    try {
+        fs.chmodSync(configPath, 0o600);
+    }
+    catch {
+        // chmodSync may fail on some platforms (e.g. Windows). Non-fatal.
+    }
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`[eliza-config] Config file missing after write: ${configPath}`);
+    }
+    const stat = fs.statSync(configPath);
+    if (stat.size === 0) {
+        throw new Error(`[eliza-config] Config file is empty after write: ${configPath}`);
+    }
+    if (isElizaSettingsDebugEnabled()) {
+        const c = sanitized;
+        const cloud = c.cloud;
+        logger.debug({
+            path: configPath,
+            bytes: stat.size,
+            topLevelKeys: Object.keys(c).sort(),
+            cloud: settingsDebugCloudSummary(cloud),
+            snapshot: sanitizeForSettingsDebug(sanitized),
+        }, "[eliza][settings][saveElizaConfig]");
+    }
+}
+export function configFileExists() {
+    const configPath = resolveConfigPath();
+    if (fs.existsSync(configPath)) {
+        return true;
+    }
+    const persistPath = resolveConfigWritePath();
+    return persistPath !== configPath && fs.existsSync(persistPath);
+}
+// Backward-compat aliases for downstream forks using the old name

package/config/env-vars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-vars.d.ts","sourceRoot":"","sources":["../../src/config/env-vars.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAmD9C;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CACtC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAuFjD,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,GAAG,CAAC,EAAE,WAAW,GAChB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAkCxB;AAED,wBAAgB,uBAAuB,CACrC,GAAG,CAAC,EAAE,WAAW,GAChB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAsIxB"}

package/config/feature-flags.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Centralised readers for Eliza feature flags that gate unreleased or
+ * in-progress integrations. Keep this module dependency-free so it can be
+ * imported from any layer (api, runtime, cloud) without cycles.
+ *
+ * Flags live in `process.env` (set via `config.env` on disk). They are read
+ * each call so a runtime restart picks up changes without a module reload.
+ */
+/**
+ * Eliza Cloud remote-signing wallet bridge.
+ *
+ * When on: `POST /api/cloud/login/status` provisions cloud wallets, writes
+ * `WALLET_SOURCE_*`, and the UI exposes a dual-wallet (local | cloud) picker.
+ * When off: zero cloud-wallet code paths run; wallet UI/API behave as before.
+ */
+export declare function isCloudWalletEnabled(): boolean;
+/**
+ * Opt-in for older external workspaces that still store app plugins under
+ * `apps/app-*` rather than the current `plugins/app-*` layout.
+ *
+ * Default off. The Eliza repo itself no longer scans top-level `apps/` by
+ * default. Set `ELIZA_ENABLE_LEGACY_APPS_WORKSPACE_DISCOVERY=1` to re-enable
+ * the old scan path when working with a workspace that has not migrated yet.
+ */
+export declare function isLegacyAppsWorkspaceDiscoveryEnabled(): boolean;
+//# sourceMappingURL=feature-flags.d.ts.map

package/config/feature-flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flags.d.ts","sourceRoot":"","sources":["../../src/config/feature-flags.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAyBH;;;;;;GAMG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAED;;;;;;;GAOG;AACH,wBAAgB,qCAAqC,IAAI,OAAO,CAE/D"}

package/config/feature-flags.js

@@ -0,0 +1,48 @@
+/**
+ * Centralised readers for Eliza feature flags that gate unreleased or
+ * in-progress integrations. Keep this module dependency-free so it can be
+ * imported from any layer (api, runtime, cloud) without cycles.
+ *
+ * Flags live in `process.env` (set via `config.env` on disk). They are read
+ * each call so a runtime restart picks up changes without a module reload.
+ */
+function readBoolFlag(name, fallback = false) {
+    const raw = process.env[name];
+    if (raw === undefined || raw === null || raw === "")
+        return fallback;
+    const trimmed = String(raw).trim().toLowerCase();
+    if (trimmed === "1" ||
+        trimmed === "true" ||
+        trimmed === "yes" ||
+        trimmed === "on") {
+        return true;
+    }
+    if (trimmed === "0" ||
+        trimmed === "false" ||
+        trimmed === "no" ||
+        trimmed === "off") {
+        return false;
+    }
+    return fallback;
+}
+/**
+ * Eliza Cloud remote-signing wallet bridge.
+ *
+ * When on: `POST /api/cloud/login/status` provisions cloud wallets, writes
+ * `WALLET_SOURCE_*`, and the UI exposes a dual-wallet (local | cloud) picker.
+ * When off: zero cloud-wallet code paths run; wallet UI/API behave as before.
+ */
+export function isCloudWalletEnabled() {
+    return readBoolFlag("ENABLE_CLOUD_WALLET");
+}
+/**
+ * Opt-in for older external workspaces that still store app plugins under
+ * `apps/app-*` rather than the current `plugins/app-*` layout.
+ *
+ * Default off. The Eliza repo itself no longer scans top-level `apps/` by
+ * default. Set `ELIZA_ENABLE_LEGACY_APPS_WORKSPACE_DISCOVERY=1` to re-enable
+ * the old scan path when working with a workspace that has not migrated yet.
+ */
+export function isLegacyAppsWorkspaceDiscoveryEnabled() {
+    return readBoolFlag("ELIZA_ENABLE_LEGACY_APPS_WORKSPACE_DISCOVERY");
+}

package/config/includes.d.ts

@@ -0,0 +1,26 @@
+/**
+ * $include directive for modular configs.
+ *
+ * ```json5
+ * { "$include": "./base.json5" }
+ * { "$include": ["./a.json5", "./b.json5"] }
+ * ```
+ */
+export declare const INCLUDE_KEY = "$include";
+export declare const MAX_INCLUDE_DEPTH = 10;
+export type IncludeResolver = {
+    readFile: (path: string) => string;
+    parseJson: (raw: string) => unknown;
+};
+export declare class ConfigIncludeError extends Error {
+    readonly includePath: string;
+    readonly cause?: Error | undefined;
+    constructor(message: string, includePath: string, cause?: Error | undefined);
+}
+export declare class CircularIncludeError extends ConfigIncludeError {
+    readonly chain: string[];
+    constructor(chain: string[]);
+}
+export declare function deepMerge(target: unknown, source: unknown): unknown;
+export declare function resolveConfigIncludes(obj: unknown, configPath: string, resolver?: IncludeResolver): unknown;
+//# sourceMappingURL=includes.d.ts.map

package/config/includes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"includes.d.ts","sourceRoot":"","sources":["../../src/config/includes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAUH,eAAO,MAAM,WAAW,aAAa,CAAC;AACtC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAGpC,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACnC,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CACrC,CAAC;AAEF,qBAAa,kBAAmB,SAAQ,KAAK;aAGzB,WAAW,EAAE,MAAM;aACnB,KAAK,CAAC,EAAE,KAAK;gBAF7B,OAAO,EAAE,MAAM,EACC,WAAW,EAAE,MAAM,EACnB,KAAK,CAAC,EAAE,KAAK,YAAA;CAKhC;AAED,qBAAa,oBAAqB,SAAQ,kBAAkB;aAC9B,KAAK,EAAE,MAAM,EAAE;gBAAf,KAAK,EAAE,MAAM,EAAE;CAO5C;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAcnE;AAoID,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,OAAO,EACZ,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,eAAiC,GAC1C,OAAO,CAET"}

package/config/includes.js

@@ -0,0 +1,151 @@
+/**
+ * $include directive for modular configs.
+ *
+ * ```json5
+ * { "$include": "./base.json5" }
+ * { "$include": ["./a.json5", "./b.json5"] }
+ * ```
+ */
+import fs from "node:fs";
+import path from "node:path";
+import JSON5 from "json5";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export const INCLUDE_KEY = "$include";
+export const MAX_INCLUDE_DEPTH = 10;
+const BLOCKED_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+export class ConfigIncludeError extends Error {
+    includePath;
+    cause;
+    constructor(message, includePath, cause) {
+        super(message);
+        this.includePath = includePath;
+        this.cause = cause;
+        this.name = "ConfigIncludeError";
+    }
+}
+export class CircularIncludeError extends ConfigIncludeError {
+    chain;
+    constructor(chain) {
+        super(`Circular include detected: ${chain.join(" -> ")}`, chain[chain.length - 1] ?? "");
+        this.chain = chain;
+        this.name = "CircularIncludeError";
+    }
+}
+export function deepMerge(target, source) {
+    if (Array.isArray(target) && Array.isArray(source)) {
+        return [...target, ...source];
+    }
+    if (isPlainObject(target) && isPlainObject(source)) {
+        const result = { ...target };
+        for (const key of Object.keys(source)) {
+            if (BLOCKED_KEYS.has(key))
+                continue;
+            result[key] =
+                key in result ? deepMerge(result[key], source[key]) : source[key];
+        }
+        return result;
+    }
+    return source;
+}
+class IncludeProcessor {
+    basePath;
+    resolver;
+    visited = new Set();
+    depth = 0;
+    constructor(basePath, resolver) {
+        this.basePath = basePath;
+        this.resolver = resolver;
+        this.visited.add(path.normalize(basePath));
+    }
+    process(obj) {
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this.process(item));
+        }
+        if (!isPlainObject(obj)) {
+            return obj;
+        }
+        const record = obj;
+        if (!(INCLUDE_KEY in record)) {
+            return this.processObject(record);
+        }
+        return this.processInclude(record);
+    }
+    processObject(obj) {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (BLOCKED_KEYS.has(key))
+                continue;
+            result[key] = this.process(value);
+        }
+        return result;
+    }
+    processInclude(obj) {
+        const includeValue = obj[INCLUDE_KEY];
+        const otherKeys = Object.keys(obj).filter((k) => k !== INCLUDE_KEY);
+        const included = this.resolveInclude(includeValue);
+        if (otherKeys.length === 0) {
+            return included;
+        }
+        if (!isPlainObject(included)) {
+            throw new ConfigIncludeError("Sibling keys require included content to be an object", typeof includeValue === "string" ? includeValue : INCLUDE_KEY);
+        }
+        const rest = {};
+        for (const key of otherKeys) {
+            rest[key] = this.process(obj[key]);
+        }
+        return deepMerge(included, rest);
+    }
+    resolveInclude(value) {
+        if (typeof value === "string") {
+            return this.loadFile(value);
+        }
+        if (Array.isArray(value)) {
+            return value.reduce((merged, item) => {
+                if (typeof item !== "string") {
+                    throw new ConfigIncludeError(`Invalid $include array item: expected string, got ${typeof item}`, String(item));
+                }
+                return deepMerge(merged, this.loadFile(item));
+            }, {});
+        }
+        throw new ConfigIncludeError(`Invalid $include value: expected string or array of strings, got ${typeof value}`, String(value));
+    }
+    loadFile(includePath) {
+        const resolvedPath = path.isAbsolute(includePath)
+            ? includePath
+            : path.resolve(path.dirname(this.basePath), includePath);
+        const normalized = path.normalize(resolvedPath);
+        if (this.visited.has(normalized)) {
+            throw new CircularIncludeError([...this.visited, normalized]);
+        }
+        if (this.depth >= MAX_INCLUDE_DEPTH) {
+            throw new ConfigIncludeError(`Maximum include depth (${MAX_INCLUDE_DEPTH}) exceeded at: ${includePath}`, includePath);
+        }
+        let raw;
+        try {
+            raw = this.resolver.readFile(normalized);
+        }
+        catch (err) {
+            throw new ConfigIncludeError(`Failed to read include file: ${includePath} (resolved: ${normalized})`, includePath, err instanceof Error ? err : undefined);
+        }
+        let parsed;
+        try {
+            parsed = this.resolver.parseJson(raw);
+        }
+        catch (err) {
+            throw new ConfigIncludeError(`Failed to parse include file: ${includePath} (resolved: ${normalized})`, includePath, err instanceof Error ? err : undefined);
+        }
+        const nested = new IncludeProcessor(normalized, this.resolver);
+        nested.visited = new Set([...this.visited, normalized]);
+        nested.depth = this.depth + 1;
+        return nested.process(parsed);
+    }
+}
+const defaultResolver = {
+    readFile: (p) => fs.readFileSync(p, "utf-8"),
+    parseJson: (raw) => JSON5.parse(raw),
+};
+export function resolveConfigIncludes(obj, configPath, resolver = defaultResolver) {
+    return new IncludeProcessor(configPath, resolver).process(obj);
+}

package/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,+BAA+B,CAAC;AAC9C,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,kBAAkB,CAAC"}

package/config/model-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-metadata.d.ts","sourceRoot":"","sources":["../../src/config/model-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,qBAAqB,EAEtB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,4BAA4B,SAAU,CAAC;AACpD,eAAO,MAAM,wBAAwB,OAAQ,CAAC;AAU9C,MAAM,MAAM,wBAAwB,GAChC,cAAc,GACd,gBAAgB,GAChB,iBAAiB,CAAC;AAEtB,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,wBAAwB,CAAC;CAClC;AAyCD,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,OAAO,CAAC,qBAAqB,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EACtD,QAAQ,CAAC,EAAE;IACT,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GACA,qBAAqB,CAuBvB;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAmBxE;AAkDD,wBAAgB,yBAAyB,CACvC,MAAM,CAAC,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,MAAM,GACf,kBAAkB,CA+BpB"}