@zudojs/core 0.0.1 → 1.0.0

package/dist/configuration/error/configurationRedactor.redactor.js

@@ -7,6 +7,8 @@
 export const DEFAULT_SENSITIVE_PATTERNS = [
     "password",
     "passwd",
+    "pwd",
+    "passphrase",
     "secret",
     "token",
     "access_token",
@@ -17,8 +19,12 @@ export const DEFAULT_SENSITIVE_PATTERNS = [
     "privatekey",
     "client_secret",
     "authorization",
+    "auth",
     "credential",
     "credentials",
+    "dsn",
+    "connectionstring",
+    "connection_string",
 ];
 /**
  * Default value used when a sensitive configuration value
@@ -62,7 +68,11 @@ export class ConfigurationRedactor {
                 reason: "exact-path",
             };
         }
-        const pathSegments = normalizedPath.split(".");
+        /*
+         * Pattern matching runs on the original casing so camelCase
+         * word boundaries (apiToken → api token) survive.
+         */
+        const pathSegments = path.trim().split(".");
         for (const segment of pathSegments) {
             if (this.matchesSensitivePattern(segment)) {
                 return {
@@ -71,7 +81,7 @@ export class ConfigurationRedactor {
                 };
             }
         }
-        if (this.matchesSensitivePattern(normalizedPath)) {
+        if (this.matchesSensitivePattern(path.trim())) {
             return {
                 sensitive: true,
                 reason: "pattern",
@@ -129,7 +139,12 @@ export class ConfigurationRedactor {
             }
             return value.map((item, index) => this.redactValue(item, parentPath ? `${parentPath}.${index}` : String(index)));
         }
-        const result = {};
+        /*
+         * The result is built with a null prototype so keys such as
+         * "__proto__" are stored as ordinary own properties instead
+         * of hitting Object.prototype setters and vanishing.
+         */
+        const result = Object.create(null);
         for (const [key, childValue] of Object.entries(value)) {
             const path = parentPath ? `${parentPath}.${key}` : key;
             if (this.isSensitive(path)) {
@@ -143,11 +158,74 @@ export class ConfigurationRedactor {
     /**
      * Checks whether a path segment matches one of the
      * configured sensitive patterns.
+     *
+     * Matching is word-boundary aware: the segment is split into
+     * words on separators and camelCase transitions, and a pattern
+     * matches only when a consecutive run of words spells it out.
+     * This means "apiToken" and "access_token" match "token", but
+     * "tokenizer" and "secretary" do not match "token"/"secret".
      */
     matchesSensitivePattern(value) {
-        const normalized = normalizePattern(value);
-        return this.sensitivePatterns.some((pattern) => normalized.includes(pattern));
+        const words = splitWords(value);
+        if (words.length === 0) {
+            return false;
+        }
+        return this.sensitivePatterns.some((pattern) => matchesWordRun(words, pattern));
+    }
+    /**
+     * Redacts sensitive-looking fragments from free-form text such
+     * as error messages.
+     *
+     * Occurrences of "<sensitive>=value", "<sensitive>: value", and
+     * "<sensitive> value" have their value replaced. This is a
+     * best-effort scrub for diagnostics; it does not guarantee that
+     * arbitrary text contains no secrets.
+     */
+    redactText(text) {
+        let result = text;
+        for (const pattern of this.sensitivePatterns) {
+            const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            const expression = new RegExp(`(${escaped}[a-z0-9_-]*\\s*[=:]\\s*)("[^"]*"|'[^']*'|\\S+)`, "gi");
+            result = result.replace(expression, `$1${this.redactionValue}`);
+        }
+        return result;
+    }
+}
+/**
+ * Splits an identifier into normalized lowercase words.
+ *
+ * Splitting occurs on non-alphanumeric separators and on
+ * camelCase transitions.
+ */
+function splitWords(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .split(/[^a-zA-Z0-9]+/)
+        .map((word) => word.toLowerCase())
+        .filter((word) => word.length > 0);
+}
+/**
+ * Checks whether a consecutive run of words spells out
+ * the supplied pattern.
+ */
+function matchesWordRun(words, pattern) {
+    const target = splitWords(pattern).join("");
+    if (!target) {
+        return false;
+    }
+    for (let start = 0; start < words.length; start++) {
+        let accumulated = "";
+        for (let index = start; index < words.length; index++) {
+            accumulated += words[index];
+            if (accumulated === target) {
+                return true;
+            }
+            if (accumulated.length >= target.length) {
+                break;
+            }
+        }
     }
+    return false;
 }
 /**
  * Creates a ConfigurationRedactor.

package/dist/configuration/error/index.d.ts

@@ -3,7 +3,8 @@
  *
  * Configuration errors and redaction.
  */
-export { ConfigurationError, ConfigurationSourceError, ConfigurationMissingError, ConfigurationTypeError, ConfigurationSchemaError, ConfigurationConflictError, } from "./configurationError.error.js";
+export { ConfigurationError, ConfigurationSourceError, ConfigurationMissingError, ConfigurationPathError, ConfigurationTypeError, ConfigurationSchemaError, ConfigurationConflictError, } from "./configurationError.error.js";
+export { describeConfigurationCause } from "./configurationError.error.js";
 export type { ConfigurationErrorIssue } from "./configurationError.error.js";
 export { ConfigurationRedactor, createConfigurationRedactor, redactConfiguration, DEFAULT_SENSITIVE_PATTERNS, DEFAULT_REDACTION_VALUE, } from "./configurationRedactor.redactor.js";
 export type { ConfigurationRedactorOptions, ConfigurationSensitivity, RedactedConfiguration, } from "./configurationRedactor.redactor.js";

package/dist/configuration/error/index.js

@@ -3,6 +3,7 @@
  *
  * Configuration errors and redaction.
  */
-export { ConfigurationError, ConfigurationSourceError, ConfigurationMissingError, ConfigurationTypeError, ConfigurationSchemaError, ConfigurationConflictError, } from "./configurationError.error.js";
+export { ConfigurationError, ConfigurationSourceError, ConfigurationMissingError, ConfigurationPathError, ConfigurationTypeError, ConfigurationSchemaError, ConfigurationConflictError, } from "./configurationError.error.js";
+export { describeConfigurationCause } from "./configurationError.error.js";
 export { ConfigurationRedactor, createConfigurationRedactor, redactConfiguration, DEFAULT_SENSITIVE_PATTERNS, DEFAULT_REDACTION_VALUE, } from "./configurationRedactor.redactor.js";
 //# sourceMappingURL=index.js.map

package/dist/configuration/index.d.ts

@@ -22,7 +22,7 @@ export * from "./error/index.js";
  * Configuration manager.
  */
 export { ConfigurationManager, ConfigurationManagerState, createConfigurationManager, } from "./configurationManager.manager.js";
-export type { ConfigurationManagerOptions, ConfigurationManagerResult, } from "./configurationManager.manager.js";
+export type { ConfigurationManagerOptions, ConfigurationManagerResult, ConfigurationEventSubscription, } from "./configurationManager.manager.js";
 /**
  * Configuration lifecycle events.
  */

package/dist/configuration/loader/configurationLoader.loader.d.ts

@@ -1,5 +1,6 @@
 import { Configuration } from "../core/configuration.js";
-import type { ConfigurationSource } from "../core/configurationSource.source.js";
+import type { ConfigurationSource, ConfigurationSourceEntry } from "../core/configurationSource.source.js";
+import { ConfigurationSourceError } from "../error/configurationError.error.js";
 /**
  * Options for loading configuration.
  */
@@ -35,6 +36,13 @@ export interface ConfigurationLoadResult {
      */
     readonly entryCount: number;
 }
+/**
+ * Applies entries from one source onto a configuration.
+ *
+ * Higher level components (loader, provider) share this logic so
+ * source precedence behaves identically everywhere.
+ */
+export declare function applyConfigurationSourceEntries(configuration: Configuration, source: ConfigurationSource, entries: readonly ConfigurationSourceEntry[]): Configuration;
 /**
  * Loads and combines configuration from multiple sources.
  *
@@ -51,8 +59,14 @@ export declare class ConfigurationLoader {
      * Sources are ordered by ascending priority.
      * Higher priority sources are therefore applied later
      * and override lower priority values.
+     *
+     * Additional sources (for example, sources registered with a
+     * ConfigurationRegistry) can be supplied; they are merged with
+     * the loader's own sources and ordered by priority. When an
+     * extra source shares a name with a registered source, the
+     * loader's own source wins.
      */
-    load(): Promise<ConfigurationLoadResult>;
+    load(extraSources?: readonly ConfigurationSource[]): Promise<ConfigurationLoadResult>;
     /**
      * Loads sources sequentially.
      *
@@ -65,16 +79,15 @@ export declare class ConfigurationLoader {
      * Even though loading happens concurrently, entries are
      * applied according to source priority to preserve
      * deterministic precedence.
+     *
+     * All sources are attempted; when any fail, a single
+     * aggregated error listing every failed source is thrown.
      */
     private loadConcurrently;
     /**
      * Loads a single configuration source.
      */
     private loadSource;
-    /**
-     * Applies source entries to the configuration.
-     */
-    private applyEntries;
     /**
      * Returns sources ordered by priority.
      *
@@ -100,11 +113,36 @@ export declare class ConfigurationLoader {
     clearSources(): void;
 }
 /**
- * Error thrown when a configuration source cannot be loaded.
+ * Error thrown when one or more configuration sources cannot
+ * be loaded.
+ *
+ * A ConfigurationSourceError (code CONFIGURATION_LOAD_FAILED)
+ * that additionally carries the failed source object(s), so
+ * callers can catch load failures by either type or by code. Raw
+ * cause text is redacted before being embedded in the message.
  */
-export declare class ConfigurationLoadError extends Error {
-    readonly source: ConfigurationSource;
+export declare class ConfigurationLoadError extends ConfigurationSourceError {
+    /**
+     * The source that failed, for single-source failures.
+     */
+    readonly source?: ConfigurationSource;
+    /**
+     * Every failed source, for aggregate failures. Contains a
+     * single element for single-source failures.
+     */
+    readonly failures: readonly {
+        readonly source: ConfigurationSource;
+        readonly error: unknown;
+    }[];
     constructor(source: ConfigurationSource, cause: unknown);
+    /**
+     * Creates a single aggregated load error listing every
+     * failed source.
+     */
+    static aggregate(failures: readonly {
+        readonly source: ConfigurationSource;
+        readonly error: unknown;
+    }[]): ConfigurationLoadError;
 }
 /**
  * Creates a ConfigurationLoader.

package/dist/configuration/loader/configurationLoader.loader.js

@@ -1,4 +1,23 @@
 import { Configuration } from "../core/configuration.js";
+import { sortConfigurationSources } from "../core/configurationSource.source.js";
+import { ConfigurationSourceError, describeConfigurationCause, } from "../error/configurationError.error.js";
+/**
+ * Applies entries from one source onto a configuration.
+ *
+ * Higher level components (loader, provider) share this logic so
+ * source precedence behaves identically everywhere.
+ */
+export function applyConfigurationSourceEntries(configuration, source, entries) {
+    let result = configuration;
+    for (const entry of entries) {
+        const path = entry.path.trim();
+        if (!path) {
+            throw new ConfigurationLoadError(source, new Error("Configuration entry path cannot be empty."));
+        }
+        result = result.with(path, entry.value, source.type);
+    }
+    return result;
+}
 /**
  * Loads and combines configuration from multiple sources.
  *
@@ -18,9 +37,15 @@ export class ConfigurationLoader {
      * Sources are ordered by ascending priority.
      * Higher priority sources are therefore applied later
      * and override lower priority values.
+     *
+     * Additional sources (for example, sources registered with a
+     * ConfigurationRegistry) can be supplied; they are merged with
+     * the loader's own sources and ordered by priority. When an
+     * extra source shares a name with a registered source, the
+     * loader's own source wins.
      */
-    async load() {
-        const sources = this.getSortedSources();
+    async load(extraSources = []) {
+        const sources = this.getSortedSources(extraSources);
         if (this.sequential) {
             return this.loadSequentially(sources);
         }
@@ -36,7 +61,7 @@ export class ConfigurationLoader {
         let entryCount = 0;
         for (const source of sources) {
             const entries = await this.loadSource(source);
-            configuration = this.applyEntries(configuration, entries, source);
+            configuration = applyConfigurationSourceEntries(configuration, source, entries);
             entryCount += entries.length;
         }
         return {
@@ -51,16 +76,32 @@ export class ConfigurationLoader {
      * Even though loading happens concurrently, entries are
      * applied according to source priority to preserve
      * deterministic precedence.
+     *
+     * All sources are attempted; when any fail, a single
+     * aggregated error listing every failed source is thrown.
      */
     async loadConcurrently(sources) {
-        const loaded = await Promise.all(sources.map(async (source) => ({
+        const settled = await Promise.allSettled(sources.map(async (source) => ({
             source,
             entries: await this.loadSource(source),
         })));
+        const failures = [];
+        const loaded = [];
+        for (let index = 0; index < settled.length; index++) {
+            const result = settled[index];
+            if (result.status === "fulfilled") {
+                loaded.push(result.value);
+                continue;
+            }
+            failures.push({ source: sources[index], error: result.reason });
+        }
+        if (failures.length > 0) {
+            throw ConfigurationLoadError.aggregate(failures);
+        }
         let configuration = new Configuration();
         let entryCount = 0;
         for (const result of loaded) {
-            configuration = this.applyEntries(configuration, result.entries, result.source);
+            configuration = applyConfigurationSourceEntries(configuration, result.source, result.entries);
             entryCount += result.entries.length;
         }
         return {
@@ -81,28 +122,21 @@ export class ConfigurationLoader {
             throw new ConfigurationLoadError(source, error);
         }
     }
-    /**
-     * Applies source entries to the configuration.
-     */
-    applyEntries(configuration, entries, source) {
-        let result = configuration;
-        for (const entry of entries) {
-            const path = entry.path.trim();
-            if (!path) {
-                throw new ConfigurationLoadError(source, new Error("Configuration entry path cannot be empty."));
-            }
-            result = result.with(path, entry.value, source.type);
-        }
-        return result;
-    }
     /**
      * Returns sources ordered by priority.
      *
      * Lower priority sources are loaded first.
      * Higher priority sources override them.
      */
-    getSortedSources() {
-        return [...this.sources].sort((a, b) => a.priority - b.priority);
+    getSortedSources(extraSources = []) {
+        const merged = new Map();
+        for (const source of extraSources) {
+            merged.set(source.name, source);
+        }
+        for (const source of this.sources) {
+            merged.set(source.name, source);
+        }
+        return sortConfigurationSources([...merged.values()]);
     }
     /**
      * Adds a configuration source.
@@ -135,15 +169,62 @@ export class ConfigurationLoader {
     }
 }
 /**
- * Error thrown when a configuration source cannot be loaded.
+ * Error thrown when one or more configuration sources cannot
+ * be loaded.
+ *
+ * A ConfigurationSourceError (code CONFIGURATION_LOAD_FAILED)
+ * that additionally carries the failed source object(s), so
+ * callers can catch load failures by either type or by code. Raw
+ * cause text is redacted before being embedded in the message.
  */
-export class ConfigurationLoadError extends Error {
+export class ConfigurationLoadError extends ConfigurationSourceError {
+    /**
+     * The source that failed, for single-source failures.
+     */
     source;
+    /**
+     * Every failed source, for aggregate failures. Contains a
+     * single element for single-source failures.
+     */
+    failures;
     constructor(source, cause) {
-        const message = cause instanceof Error ? cause.message : String(cause);
-        super(`Failed to load configuration source "${source.name}": ${message}`);
+        super(source.name, source.type, cause);
+        this.name = "ConfigurationLoadError";
         this.source = source;
-        this.cause = cause;
+        this.failures = Object.freeze([{ source, error: cause }]);
+    }
+    /**
+     * Creates a single aggregated load error listing every
+     * failed source.
+     */
+    static aggregate(failures) {
+        if (failures.length === 1) {
+            const failure = failures[0];
+            const single = failure.error;
+            if (single instanceof ConfigurationLoadError)
+                return single;
+            return new ConfigurationLoadError(failure.source, single);
+        }
+        const first = failures[0];
+        const error = new ConfigurationLoadError(first.source, first.error);
+        const summary = failures
+            .map((failure) => `"${failure.source.name}": ${describeConfigurationCause(failure.error instanceof ConfigurationLoadError
+            ? (failure.error.cause ?? failure.error)
+            : failure.error)}`)
+            .join("; ");
+        Object.defineProperty(error, "message", {
+            value: `Failed to load ${failures.length} configuration sources: ${summary}`,
+            configurable: true,
+            writable: true,
+        });
+        Object.defineProperty(error, "failures", {
+            value: Object.freeze(failures.map((failure) => ({
+                source: failure.source,
+                error: failure.error,
+            }))),
+            configurable: true,
+        });
+        return error;
     }
 }
 /**

package/dist/configuration/loader/index.d.ts

@@ -3,6 +3,6 @@
  *
  * Configuration loading pipeline.
  */
-export { ConfigurationLoader, ConfigurationLoadError, createConfigurationLoader, } from "./configurationLoader.loader.js";
+export { ConfigurationLoader, ConfigurationLoadError, createConfigurationLoader, applyConfigurationSourceEntries, } from "./configurationLoader.loader.js";
 export type { ConfigurationLoaderOptions, ConfigurationLoadResult, } from "./configurationLoader.loader.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/configuration/loader/index.js

@@ -3,5 +3,5 @@
  *
  * Configuration loading pipeline.
  */
-export { ConfigurationLoader, ConfigurationLoadError, createConfigurationLoader, } from "./configurationLoader.loader.js";
+export { ConfigurationLoader, ConfigurationLoadError, createConfigurationLoader, applyConfigurationSourceEntries, } from "./configurationLoader.loader.js";
 //# sourceMappingURL=index.js.map

package/dist/configuration/registry/configurationProvider.provider.d.ts

@@ -43,6 +43,15 @@ export interface ConfigurationProvider {
      * registered with the provider.
      */
     getSources(): readonly ConfigurationSource[];
+    /**
+     * Replaces the provider's active configuration.
+     *
+     * Optional: providers that build configuration exclusively
+     * from their own sources may omit it. When present, it is used
+     * by ConfigurationManager to push loaded configuration into
+     * the provider.
+     */
+    setConfiguration?(configuration: Configuration): void;
 }
 /**
  * Options used to create a ConfigurationProvider.
@@ -65,7 +74,15 @@ export interface ConfigurationProviderOptions {
  */
 export declare class DefaultConfigurationProvider implements ConfigurationProvider {
     private configuration;
+    /**
+     * Configuration supplied at construction time.
+     *
+     * Reloads layer source values on top of this configuration so
+     * programmatic defaults survive a reload.
+     */
+    private readonly initialConfiguration;
     private readonly sources;
+    private reloadPromise;
     constructor(options?: ConfigurationProviderOptions);
     /**
      * Returns the current configuration.
@@ -95,9 +112,17 @@ export declare class DefaultConfigurationProvider implements ConfigurationProvid
      * Reloads configuration from all registered sources.
      *
      * Sources are loaded according to priority. Higher priority
-     * sources override values from lower priority sources.
+     * sources override values from lower priority sources. Values
+     * are layered on top of the initial configuration so
+     * programmatic defaults are preserved.
+     *
+     * Concurrent reload calls share a single in-flight reload.
      */
     reload(): Promise<Configuration>;
+    /**
+     * Executes one reload pass.
+     */
+    private performReload;
     /**
      * Returns the registered configuration sources.
      */

package/dist/configuration/registry/configurationProvider.provider.js

@@ -1,4 +1,6 @@
 import { Configuration } from "../core/configuration.js";
+import { sortConfigurationSources } from "../core/configurationSource.source.js";
+import { applyConfigurationSourceEntries } from "../loader/configurationLoader.loader.js";
 /**
  * Default implementation of ConfigurationProvider.
  *
@@ -7,9 +9,18 @@ import { Configuration } from "../core/configuration.js";
  */
 export class DefaultConfigurationProvider {
     configuration;
+    /**
+     * Configuration supplied at construction time.
+     *
+     * Reloads layer source values on top of this configuration so
+     * programmatic defaults survive a reload.
+     */
+    initialConfiguration;
     sources;
+    reloadPromise;
     constructor(options = {}) {
-        this.configuration = options.configuration ?? new Configuration();
+        this.initialConfiguration = options.configuration ?? new Configuration();
+        this.configuration = this.initialConfiguration;
         this.sources = [...(options.sources ?? [])];
     }
     /**
@@ -52,16 +63,31 @@ export class DefaultConfigurationProvider {
      * Reloads configuration from all registered sources.
      *
      * Sources are loaded according to priority. Higher priority
-     * sources override values from lower priority sources.
+     * sources override values from lower priority sources. Values
+     * are layered on top of the initial configuration so
+     * programmatic defaults are preserved.
+     *
+     * Concurrent reload calls share a single in-flight reload.
      */
     async reload() {
-        const sources = [...this.sources].sort((a, b) => a.priority - b.priority);
-        let configuration = new Configuration();
+        if (this.reloadPromise) {
+            return this.reloadPromise;
+        }
+        const reload = this.performReload().finally(() => {
+            this.reloadPromise = undefined;
+        });
+        this.reloadPromise = reload;
+        return reload;
+    }
+    /**
+     * Executes one reload pass.
+     */
+    async performReload() {
+        const sources = sortConfigurationSources(this.sources);
+        let configuration = this.initialConfiguration;
         for (const source of sources) {
             const entries = await source.load();
-            for (const entry of entries) {
-                configuration = configuration.with(entry.path, entry.value, source.type);
-            }
+            configuration = applyConfigurationSourceEntries(configuration, source, entries);
         }
         this.configuration = configuration;
         return configuration;

package/dist/configuration/registry/configurationRegistry.registry.js

@@ -1,4 +1,5 @@
 import { Configuration } from "../core/configuration.js";
+import { normalizeConfigurationPath } from "../core/configurationPath.path.js";
 /**
  * Registry containing configuration sources and sections
  * registered by the framework and application modules.
@@ -62,7 +63,7 @@ export class ConfigurationRegistry {
         if (this.sections.has(name)) {
             throw new Error(`Configuration section "${name}" is already registered.`);
         }
-        const path = (options.path ?? name).trim().replace(/\s+/g, "");
+        const path = normalizeConfigurationPath(options.path ?? name);
         if (!path) {
             throw new Error(`Configuration path for section "${name}" cannot be empty.`);
         }

package/dist/configuration/schema/configurationSchema.schema.d.ts

@@ -152,8 +152,4 @@ export declare class ConfigurationSchemaRegistry {
  * Creates a schema registry.
  */
 export declare function createConfigurationSchemaRegistry(): ConfigurationSchemaRegistry;
-/**
- * Validates every registered schema against a configuration.
- */
-export declare function validateConfiguration(configuration: Configuration, registry: ConfigurationSchemaRegistry): Promise<ConfigurationValidationResult<Configuration>>;
 //# sourceMappingURL=configurationSchema.schema.d.ts.map

package/dist/configuration/schema/configurationSchema.schema.js

@@ -1,3 +1,4 @@
+import { normalizeConfigurationPath } from "../core/configurationPath.path.js";
 /**
  * Creates a configuration schema.
  */
@@ -16,6 +17,16 @@ export function createConfigurationSchema(options) {
             const exists = configuration.has(path);
             if (!exists) {
                 if (options.defaultValue !== undefined) {
+                    /*
+                     * Defaults are validated too, so an invalid default
+                     * cannot silently pass validation.
+                     */
+                    if (options.validator) {
+                        return options.validator(options.defaultValue, {
+                            configuration,
+                            path,
+                        });
+                    }
                     return {
                         success: true,
                         value: options.defaultValue,
@@ -120,36 +131,4 @@ export class ConfigurationSchemaRegistry {
 export function createConfigurationSchemaRegistry() {
     return new ConfigurationSchemaRegistry();
 }
-/**
- * Validates every registered schema against a configuration.
- */
-export async function validateConfiguration(configuration, registry) {
-    const errors = [];
-    for (const schema of registry.getAll()) {
-        const result = await schema.validate(configuration);
-        if (!result.success) {
-            errors.push(...result.errors);
-        }
-    }
-    if (errors.length > 0) {
-        return {
-            success: false,
-            errors,
-        };
-    }
-    return {
-        success: true,
-        value: configuration,
-        errors: [],
-    };
-}
-/**
- * Normalizes a configuration path.
- */
-function normalizeConfigurationPath(path) {
-    if (typeof path !== "string") {
-        throw new TypeError("Configuration schema path must be a string.");
-    }
-    return path.trim().replace(/\s+/g, "");
-}
 //# sourceMappingURL=configurationSchema.schema.js.map