@terra-graph/core 1.0.0-rc.4

package/dist/cjs/Runtime/RuntimeCatalogLoader.d.ts

@@ -0,0 +1,37 @@
+import { SerializedProfile } from '../Graph/Profile.js';
+import { ProfileRegistry } from '../Graph/ProfileRegistry.js';
+import { SerializedRule } from '../Graph/Rules/RuleConfig.js';
+import { SerializedRuleSet } from '../Graph/Rules/RuleSet.js';
+import { SupportedAdapterOperationsRegistry } from '../Graph/Serialization/Registry.js';
+import { RuntimeCatalog, RuntimeCatalogProvider } from './RuntimeCatalog.js';
+export type SerializedRuntimeProfile<TOptions extends Record<string, unknown> = Record<string, unknown>> = Omit<SerializedProfile<TOptions>, 'name' | 'usesProfiles'> & {
+    usesProfiles?: string[];
+};
+export type SerializedRuntimeConfig<TOptions extends Record<string, unknown> = Record<string, unknown>> = {
+    providers?: string[];
+    namedRules?: Record<string, SerializedRule>;
+    namedRuleSets?: Record<string, SerializedRuleSet>;
+    profiles?: Record<string, SerializedRuntimeProfile<TOptions>>;
+    run?: {
+        profile: string;
+        render?: {
+            renderer?: string;
+            options?: TOptions;
+        };
+    };
+};
+export type RuntimeCatalogLoaderInput<TOptions extends Record<string, unknown> = Record<string, unknown>> = {
+    providers?: RuntimeCatalogProvider[];
+    config?: SerializedRuntimeConfig<TOptions>;
+    supportedAdapterOperationsRegistry?: SupportedAdapterOperationsRegistry;
+};
+export declare class RuntimeCatalogLoader<TOptions extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly input;
+    constructor(input?: RuntimeCatalogLoaderInput<TOptions>);
+    load(config?: SerializedRuntimeConfig<TOptions> | undefined): RuntimeCatalog;
+    fromSerialized(config: SerializedRuntimeConfig<TOptions>): RuntimeCatalog;
+    static fromSerialized<TOptions extends Record<string, unknown> = Record<string, unknown>>(config: SerializedRuntimeConfig<TOptions>, supportedAdapterOperationsRegistry?: SupportedAdapterOperationsRegistry, externalProfiles?: ProfileRegistry): RuntimeCatalog;
+    static load<TOptions extends Record<string, unknown> = Record<string, unknown>>(input?: RuntimeCatalogLoaderInput<TOptions>): RuntimeCatalog;
+    private static resolveProfilesFromSerialized;
+    private static coerceSerializedProfile;
+}

package/dist/cjs/Runtime/RuntimeCatalogLoader.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeCatalogLoader = void 0;
+const Profile_js_1 = require("../Graph/Profile.js");
+const ProfileRegistry_js_1 = require("../Graph/ProfileRegistry.js");
+const NamedRuleRegistry_js_1 = require("../Graph/Rules/NamedRuleRegistry.js");
+const NamedRuleSetRegistry_js_1 = require("../Graph/Rules/NamedRuleSetRegistry.js");
+const RuntimeCatalog_js_1 = require("./RuntimeCatalog.js");
+class RuntimeCatalogLoader {
+    input;
+    constructor(input = {}) {
+        this.input = input;
+    }
+    load(config = this.input.config) {
+        return RuntimeCatalogLoader.load({
+            ...this.input,
+            config,
+        });
+    }
+    fromSerialized(config) {
+        return RuntimeCatalogLoader.fromSerialized(config, this.input.supportedAdapterOperationsRegistry);
+    }
+    static fromSerialized(config, supportedAdapterOperationsRegistry, externalProfiles) {
+        return new RuntimeCatalog_js_1.RuntimeCatalog({
+            namedRules: new NamedRuleRegistry_js_1.NamedRuleRegistry(config.namedRules ?? {}),
+            namedRuleSets: new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry(config.namedRuleSets ?? {}),
+            profiles: RuntimeCatalogLoader.resolveProfilesFromSerialized(config.profiles ?? {}, supportedAdapterOperationsRegistry, externalProfiles),
+        });
+    }
+    static load(input = {}) {
+        const providerCatalog = RuntimeCatalog_js_1.RuntimeCatalog.from(input.providers ?? []);
+        if (!input.config) {
+            return providerCatalog;
+        }
+        return RuntimeCatalog_js_1.RuntimeCatalog.from([
+            providerCatalog,
+            RuntimeCatalogLoader.fromSerialized(input.config, input.supportedAdapterOperationsRegistry, providerCatalog.profiles),
+        ]);
+    }
+    static resolveProfilesFromSerialized(profiles, supportedAdapterOperationsRegistry, externalProfiles) {
+        const externalNames = new Set(externalProfiles?.names() ?? []);
+        const externalSerialized = new Map();
+        const definitions = new Map();
+        for (const [name, profile] of Object.entries(profiles)) {
+            definitions.set(name, {
+                profile: {
+                    name,
+                    supports: profile.supports,
+                    render: profile.render,
+                    phases: profile.phases,
+                    plugins: profile.plugins,
+                },
+                usesProfiles: [...(profile.usesProfiles ?? [])],
+            });
+        }
+        const resolved = new Map();
+        const resolve = (name, stack = []) => {
+            const existing = resolved.get(name);
+            if (existing) {
+                return existing;
+            }
+            if (stack.includes(name)) {
+                throw new Error(`Runtime config profile inheritance cycle detected: ${[...stack, name].join(' -> ')}`);
+            }
+            const definition = definitions.get(name);
+            if (!definition) {
+                throw new Error(`Runtime config profile '${name}' is not defined`);
+            }
+            const usedProfiles = definition.usesProfiles.map((used) => {
+                if (!definitions.has(used)) {
+                    if (externalNames.has(used)) {
+                        const cached = externalSerialized.get(used);
+                        if (cached) {
+                            return RuntimeCatalogLoader.coerceSerializedProfile(cached);
+                        }
+                        const externalProfile = externalProfiles?.resolve(used);
+                        if (externalProfile) {
+                            const serialized = externalProfile.serialize();
+                            externalSerialized.set(used, serialized);
+                            return RuntimeCatalogLoader.coerceSerializedProfile(serialized);
+                        }
+                    }
+                    throw new Error(`Runtime config profile '${name}' uses unknown profile '${used}'`);
+                }
+                return resolve(used, [...stack, name]);
+            });
+            const profile = {
+                ...definition.profile,
+                usesProfiles: usedProfiles,
+            };
+            resolved.set(name, profile);
+            return profile;
+        };
+        for (const name of definitions.keys()) {
+            resolve(name);
+        }
+        return new ProfileRegistry_js_1.ProfileRegistry(Object.fromEntries([...resolved.entries()].map(([name, profile]) => [
+            name,
+            () => Profile_js_1.Profile.deseriaize(profile, supportedAdapterOperationsRegistry),
+        ])));
+    }
+    static coerceSerializedProfile(profile) {
+        return profile;
+    }
+}
+exports.RuntimeCatalogLoader = RuntimeCatalogLoader;

package/dist/cjs/Runtime/RuntimeCatalogLoader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/Runtime/RuntimeCatalogLoader.test.js

@@ -0,0 +1,454 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Profile_js_1 = require("../Graph/Profile.js");
+const ProfileRegistry_js_1 = require("../Graph/ProfileRegistry.js");
+const NamedRuleRegistry_js_1 = require("../Graph/Rules/NamedRuleRegistry.js");
+const NamedRuleSetRegistry_js_1 = require("../Graph/Rules/NamedRuleSetRegistry.js");
+const RemoveNode_js_1 = require("../Graph/Rules/Node/RemoveNode.js");
+const RuntimeCatalog_js_1 = require("./RuntimeCatalog.js");
+const RuntimeCatalogLoader_js_1 = require("./RuntimeCatalogLoader.js");
+describe('RuntimeCatalogLoader.fromSerialized', () => {
+    it('shoud build runtime catalog assets from serialized config', () => {
+        const catalog = RuntimeCatalogLoader_js_1.RuntimeCatalogLoader.fromSerialized({
+            namedRules: {
+                removeAlways: {
+                    id: 'RemoveNode',
+                    config: { node: { any: true } },
+                },
+            },
+            namedRuleSets: {
+                wrapper: {
+                    rules: [{ namedRule: 'removeAlways' }],
+                },
+            },
+            profiles: {
+                'custom.profile': {
+                    phases: [
+                        {
+                            phase: 'main',
+                            rules: [{ namedRuleSet: 'wrapper' }],
+                        },
+                    ],
+                },
+            },
+        });
+        const phases = catalog.resolveProfilePhases('custom.profile');
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { any: true } },
+        });
+    });
+    it('shoud resolve serialized profile inheritance by profile name', () => {
+        const catalog = RuntimeCatalogLoader_js_1.RuntimeCatalogLoader.fromSerialized({
+            namedRules: {
+                removeBase: {
+                    id: 'RemoveNode',
+                    config: { node: { attr: { key: 'label', eq: 'base' } } },
+                },
+                removeCurrent: {
+                    id: 'RemoveNode',
+                    config: { node: { attr: { key: 'label', eq: 'current' } } },
+                },
+            },
+            profiles: {
+                base: {
+                    phases: [{ phase: 'main', rules: [{ namedRule: 'removeBase' }] }],
+                },
+                current: {
+                    usesProfiles: ['base'],
+                    phases: [{ phase: 'main', rules: [{ namedRule: 'removeCurrent' }] }],
+                },
+            },
+        });
+        const phases = catalog.resolveProfilePhases('current');
+        expect(phases).toHaveLength(2);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[1]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { attr: { key: 'label', eq: 'base' } } },
+        });
+        expect(phases[1][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { attr: { key: 'label', eq: 'current' } } },
+        });
+    });
+    it('shoud support the instance fromSerialized helper', () => {
+        const loader = new RuntimeCatalogLoader_js_1.RuntimeCatalogLoader();
+        const catalog = loader.fromSerialized({
+            profiles: {
+                profile: {
+                    phases: [],
+                },
+            },
+        });
+        expect(catalog.resolveProfilePhases('profile')).toEqual([]);
+    });
+    it('shoud surface missing profile definitions during resolution', () => {
+        const internal = RuntimeCatalogLoader_js_1.RuntimeCatalogLoader;
+        const originalGet = Map.prototype.get;
+        let callCount = 0;
+        const getSpy = jest
+            .spyOn(Map.prototype, 'get')
+            .mockImplementation(function (key) {
+            callCount += 1;
+            if (callCount === 2) {
+                return undefined;
+            }
+            return originalGet.call(this, key);
+        });
+        try {
+            expect(() => internal.resolveProfilesFromSerialized({
+                profile: { phases: [] },
+            })).toThrow("Runtime config profile 'profile' is not defined");
+        }
+        finally {
+            getSpy.mockRestore();
+        }
+    });
+    it('shoud throw when a serialized profile references an unknown parent profile', () => {
+        expect(() => RuntimeCatalogLoader_js_1.RuntimeCatalogLoader.fromSerialized({
+            profiles: {
+                current: {
+                    usesProfiles: ['base'],
+                    phases: [],
+                },
+            },
+        })).toThrow("Runtime config profile 'current' uses unknown profile 'base'");
+    });
+    it('shoud throw when serialized profiles contain inheritance cycles', () => {
+        expect(() => RuntimeCatalogLoader_js_1.RuntimeCatalogLoader.fromSerialized({
+            profiles: {
+                one: {
+                    usesProfiles: ['two'],
+                    phases: [],
+                },
+                two: {
+                    usesProfiles: ['one'],
+                    phases: [],
+                },
+            },
+        })).toThrow('Runtime config profile inheritance cycle detected: one -> two -> one');
+    });
+});
+describe('RuntimeCatalogLoader.load', () => {
+    it('shoud merge provider and serialized catalogs with config precedence', () => {
+        const providerCatalog = new RuntimeCatalog_js_1.RuntimeCatalog({
+            namedRules: new NamedRuleRegistry_js_1.NamedRuleRegistry({
+                shared: new RemoveNode_js_1.RemoveNode({
+                    node: { attr: { key: 'label', eq: 'provider' } },
+                }),
+            }),
+            namedRuleSets: new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry({
+                wrapper: {
+                    rules: [{ namedRule: 'shared' }],
+                },
+            }),
+            profiles: new ProfileRegistry_js_1.ProfileRegistry({
+                profile: new Profile_js_1.Profile('profile', {
+                    phases: [{ phase: 'main', rules: [{ namedRuleSet: 'wrapper' }] }],
+                }),
+            }),
+        });
+        const catalog = RuntimeCatalogLoader_js_1.RuntimeCatalogLoader.load({
+            providers: [providerCatalog],
+            config: {
+                namedRules: {
+                    shared: {
+                        id: 'RemoveNode',
+                        config: { node: { attr: { key: 'label', eq: 'config' } } },
+                    },
+                },
+            },
+        });
+        const phases = catalog.resolveProfilePhases('profile');
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { attr: { key: 'label', eq: 'config' } } },
+        });
+    });
+    it('shoud resolve profile inheritance from provider profiles', () => {
+        const providerCatalog = new RuntimeCatalog_js_1.RuntimeCatalog({
+            namedRules: new NamedRuleRegistry_js_1.NamedRuleRegistry({
+                removeBase: new RemoveNode_js_1.RemoveNode({
+                    node: { attr: { key: 'label', eq: 'base' } },
+                }),
+            }),
+            profiles: new ProfileRegistry_js_1.ProfileRegistry({
+                base: new Profile_js_1.Profile('base', {
+                    phases: [{ phase: 'main', rules: [{ namedRule: 'removeBase' }] }],
+                }),
+            }),
+        });
+        const catalog = RuntimeCatalogLoader_js_1.RuntimeCatalogLoader.load({
+            providers: [providerCatalog],
+            config: {
+                namedRules: {
+                    removeCurrent: {
+                        id: 'RemoveNode',
+                        config: { node: { attr: { key: 'label', eq: 'current' } } },
+                    },
+                },
+                profiles: {
+                    current: {
+                        usesProfiles: ['base'],
+                        phases: [
+                            { phase: 'main', rules: [{ namedRule: 'removeCurrent' }] },
+                        ],
+                    },
+                },
+            },
+        });
+        const phases = catalog.resolveProfilePhases('current');
+        expect(phases).toHaveLength(2);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { attr: { key: 'label', eq: 'base' } } },
+        });
+        expect(phases[1][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { attr: { key: 'label', eq: 'current' } } },
+        });
+    });
+    it('shoud return the provider catalog when config is missing', () => {
+        const providerCatalog = new RuntimeCatalog_js_1.RuntimeCatalog({
+            namedRules: new NamedRuleRegistry_js_1.NamedRuleRegistry({
+                shared: new RemoveNode_js_1.RemoveNode({
+                    node: { attr: { key: 'label', eq: 'provider' } },
+                }),
+            }),
+            namedRuleSets: new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry({
+                wrapper: {
+                    rules: [{ namedRule: 'shared' }],
+                },
+            }),
+            profiles: new ProfileRegistry_js_1.ProfileRegistry({
+                profile: new Profile_js_1.Profile('profile', {
+                    phases: [{ phase: 'main', rules: [{ namedRuleSet: 'wrapper' }] }],
+                }),
+            }),
+        });
+        const catalog = RuntimeCatalogLoader_js_1.RuntimeCatalogLoader.load({
+            providers: [providerCatalog],
+        });
+        const phases = catalog.resolveProfilePhases('profile');
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { attr: { key: 'label', eq: 'provider' } } },
+        });
+    });
+    it('shoud load serialized config when no providers are supplied', () => {
+        const catalog = RuntimeCatalogLoader_js_1.RuntimeCatalogLoader.load({
+            config: {
+                profiles: {
+                    profile: {
+                        phases: [],
+                    },
+                },
+            },
+        });
+        expect(catalog.resolveProfilePhases('profile')).toEqual([]);
+    });
+    it('shoud load an empty catalog when no input is provided', () => {
+        const catalog = RuntimeCatalogLoader_js_1.RuntimeCatalogLoader.load();
+        expect(catalog).toBeInstanceOf(RuntimeCatalog_js_1.RuntimeCatalog);
+    });
+    it('shoud support the instance loader API', () => {
+        const loader = new RuntimeCatalogLoader_js_1.RuntimeCatalogLoader({
+            config: {
+                namedRules: {
+                    removeAlways: {
+                        id: 'RemoveNode',
+                        config: { node: { any: true } },
+                    },
+                },
+                profiles: {
+                    profile: {
+                        phases: [{ phase: 'main', rules: [{ namedRule: 'removeAlways' }] }],
+                    },
+                },
+            },
+        });
+        const catalog = loader.load();
+        const phases = catalog.resolveProfilePhases('profile');
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { any: true } },
+        });
+    });
+});
+describe('RuntimeCatalogLoader.resolveProfilesFromSerialized (external profiles)', () => {
+    it('shoud resolve external profiles referenced by name', () => {
+        const providerCatalog = new RuntimeCatalog_js_1.RuntimeCatalog({
+            namedRules: new NamedRuleRegistry_js_1.NamedRuleRegistry({
+                removeBase: new RemoveNode_js_1.RemoveNode({
+                    node: { attr: { key: 'label', eq: 'base' } },
+                }),
+            }),
+            profiles: new ProfileRegistry_js_1.ProfileRegistry({
+                base: new Profile_js_1.Profile('base', {
+                    phases: [{ phase: 'main', rules: [{ namedRule: 'removeBase' }] }],
+                }),
+            }),
+        });
+        const catalog = RuntimeCatalogLoader_js_1.RuntimeCatalogLoader.load({
+            providers: [providerCatalog],
+            config: {
+                profiles: {
+                    current: {
+                        usesProfiles: ['base'],
+                        phases: [],
+                    },
+                },
+            },
+        });
+        const phases = catalog.resolveProfilePhases('current');
+        expect(phases).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { attr: { key: 'label', eq: 'base' } } },
+        });
+    });
+    it('shoud reuse cached external profiles across multiple definitions', () => {
+        const providerCatalog = new RuntimeCatalog_js_1.RuntimeCatalog({
+            namedRules: new NamedRuleRegistry_js_1.NamedRuleRegistry({
+                removeBase: new RemoveNode_js_1.RemoveNode({
+                    node: { attr: { key: 'label', eq: 'base' } },
+                }),
+            }),
+            profiles: new ProfileRegistry_js_1.ProfileRegistry({
+                base: new Profile_js_1.Profile('base', {
+                    phases: [{ phase: 'main', rules: [{ namedRule: 'removeBase' }] }],
+                }),
+            }),
+        });
+        const catalog = RuntimeCatalogLoader_js_1.RuntimeCatalogLoader.load({
+            providers: [providerCatalog],
+            config: {
+                profiles: {
+                    currentA: {
+                        usesProfiles: ['base'],
+                        phases: [],
+                    },
+                    currentB: {
+                        usesProfiles: ['base'],
+                        phases: [],
+                    },
+                },
+            },
+        });
+        expect(catalog.resolveProfilePhases('currentA')).toHaveLength(1);
+        expect(catalog.resolveProfilePhases('currentB')).toHaveLength(1);
+    });
+    it('shoud resolve external profiles via registry resolve', () => {
+        const externalProfiles = new ProfileRegistry_js_1.ProfileRegistry({
+            base: new Profile_js_1.Profile('base', {
+                phases: [],
+            }),
+        });
+        const resolveSpy = jest.spyOn(externalProfiles, 'resolve');
+        const catalog = RuntimeCatalogLoader_js_1.RuntimeCatalogLoader.fromSerialized({
+            profiles: {
+                current: {
+                    usesProfiles: ['base'],
+                    phases: [],
+                },
+            },
+        }, undefined, externalProfiles);
+        catalog.resolveProfilePhases('current');
+        expect(resolveSpy).toHaveBeenCalledWith('base');
+    });
+    it('shoud serialize external profiles when resolving', () => {
+        const externalProfiles = new ProfileRegistry_js_1.ProfileRegistry({
+            base: new Profile_js_1.Profile('base', {
+                phases: [],
+            }),
+        });
+        const resolveSpy = jest.spyOn(externalProfiles, 'resolve');
+        const serializeSpy = jest.spyOn(Profile_js_1.Profile.prototype, 'serialize');
+        const catalog = RuntimeCatalogLoader_js_1.RuntimeCatalogLoader.fromSerialized({
+            profiles: {
+                current: {
+                    usesProfiles: ['base'],
+                    phases: [],
+                },
+            },
+        }, undefined, externalProfiles);
+        catalog.resolveProfilePhases('current');
+        expect(resolveSpy).toHaveBeenCalledWith('base');
+        expect(serializeSpy).toHaveBeenCalled();
+        resolveSpy.mockRestore();
+        serializeSpy.mockRestore();
+    });
+});
+describe('RuntimeCatalogLoader.resolveProfilesFromSerialized (external profile instances)', () => {
+    it('shoud use resolved external profile definitions', () => {
+        const externalProfiles = new ProfileRegistry_js_1.ProfileRegistry({
+            base: new Profile_js_1.Profile('base', {
+                phases: [
+                    {
+                        phase: 'main',
+                        rules: [
+                            new RemoveNode_js_1.RemoveNode({
+                                node: { any: true },
+                            }),
+                        ],
+                    },
+                ],
+            }),
+        });
+        const resolveSpy = jest.spyOn(externalProfiles, 'resolve');
+        const catalog = RuntimeCatalogLoader_js_1.RuntimeCatalogLoader.fromSerialized({
+            profiles: {
+                current: {
+                    usesProfiles: ['base'],
+                    phases: [],
+                },
+            },
+        }, undefined, externalProfiles);
+        const phases = catalog.resolveProfilePhases('current');
+        expect(resolveSpy).toHaveBeenCalledWith('base');
+        expect(phases).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { any: true } },
+        });
+    });
+});
+describe('RuntimeCatalogLoader.resolveProfilesFromSerialized (external profile branch)', () => {
+    it('shoud hit the externalProfile branch when resolve returns a profile', () => {
+        const externalProfile = new Profile_js_1.Profile('base', {
+            phases: [],
+        });
+        const externalProfiles = {
+            names: () => ['base'],
+            resolve: jest.fn(() => externalProfile),
+        };
+        const internal = RuntimeCatalogLoader_js_1.RuntimeCatalogLoader;
+        const registry = internal.resolveProfilesFromSerialized({
+            current: {
+                usesProfiles: ['base'],
+                phases: [],
+            },
+        }, undefined, externalProfiles);
+        registry.resolve('current');
+        expect(externalProfiles.resolve).toHaveBeenCalledWith('base');
+    });
+    it('shoud throw when external profile name exists but resolve returns undefined', () => {
+        const externalProfiles = {
+            names: () => ['base'],
+            resolve: jest.fn(() => undefined),
+        };
+        const internal = RuntimeCatalogLoader_js_1.RuntimeCatalogLoader;
+        expect(() => internal.resolveProfilesFromSerialized({
+            current: {
+                usesProfiles: ['base'],
+                phases: [],
+            },
+        }, undefined, externalProfiles)).toThrow(`Runtime config profile 'current' uses unknown profile 'base'`);
+    });
+});

package/dist/cjs/Runtime/RuntimeConfigLoader.d.ts

@@ -0,0 +1,33 @@
+import { RuntimeCatalog } from './RuntimeCatalog.js';
+import { RuntimeCatalogBuilder } from './RuntimeCatalogBuilder.js';
+import { SerializedRuntimeConfig } from './RuntimeCatalogLoader.js';
+import { RuntimeConfigParserRegistry } from './RuntimeConfigParserRegistry.js';
+import { RuntimeConfigSource } from './RuntimeConfigSource.js';
+import { RuntimeConfigValidator } from './RuntimeConfigValidator.js';
+import { RuntimeProvider } from './RuntimeProvider.js';
+import { RuntimeProviderLoader } from './RuntimeProviderLoader.js';
+export type RuntimeConfigLoadInput<TOptions extends Record<string, unknown> = Record<string, unknown>> = {
+    source: RuntimeConfigSource;
+};
+export type RuntimeConfigLoadResult<TOptions extends Record<string, unknown> = Record<string, unknown>> = {
+    catalog: RuntimeCatalog;
+    config: SerializedRuntimeConfig<TOptions>;
+};
+export type RuntimeConfigLoaderDependencies<TOptions extends Record<string, unknown> = Record<string, unknown>> = {
+    parserRegistry?: RuntimeConfigParserRegistry;
+    validator?: RuntimeConfigValidator<TOptions>;
+    catalogBuilder?: RuntimeCatalogBuilder<TOptions>;
+    providerLoader?: RuntimeProviderLoader;
+    baseProviders?: RuntimeProvider[];
+};
+export declare class RuntimeConfigLoader<TOptions extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly parserRegistry;
+    private readonly validator;
+    private readonly catalogBuilder;
+    private readonly providerLoader;
+    private readonly baseProviders;
+    constructor(dependencies?: RuntimeConfigLoaderDependencies<TOptions>);
+    load(input: RuntimeConfigLoadInput<TOptions>): Promise<RuntimeConfigLoadResult<TOptions>>;
+    private loadProviders;
+    private mergeSupportedAdapterOperationsRegistry;
+}