@terra-graph/core 1.0.0-rc.4

package/dist/esm/Runtime/RuntimeConfigLoader.test.js

@@ -0,0 +1,343 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { DotAdapter } from '../Graph/Adapters/DotAdapter.js';
+import { Profile } from '../Graph/Profile.js';
+import { ProfileRegistry } from '../Graph/ProfileRegistry.js';
+import { NamedRuleRegistry } from '../Graph/Rules/NamedRuleRegistry.js';
+import { NamedRuleSetRegistry } from '../Graph/Rules/NamedRuleSetRegistry.js';
+import { RemoveNode } from '../Graph/Rules/Node/RemoveNode.js';
+import { RuntimeConfigLoader } from './RuntimeConfigLoader.js';
+import { RuntimeConfigParserRegistry } from './RuntimeConfigParserRegistry.js';
+import { FileRuntimeConfigSource } from './RuntimeConfigSource/FileRuntimeConfigSource.js';
+import { InMemoryRuntimeConfigSource } from './RuntimeConfigSource/InMemoryRuntimeConfigSource.js';
+describe('RuntimeConfigParserRegistry.resolve', () => {
+    it('shoud resolve default json and yaml parsers', () => {
+        const registry = RuntimeConfigParserRegistry.defaults();
+        expect(registry.resolve('json').parse('{"a":1}')).toEqual({ a: 1 });
+        expect(registry.resolve('yaml').parse('value: ok')).toEqual({
+            value: 'ok',
+        });
+    });
+    it('shoud throw when no parser is registered for a format', () => {
+        const registry = RuntimeConfigParserRegistry.defaults();
+        expect(() => registry.resolve('toml')).toThrow("No RuntimeConfigParser registered for format 'toml'");
+    });
+});
+describe('FileRuntimeConfigSource.read', () => {
+    it('shoud read file contents and infer format from file extension', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'runtime-config-loader-'));
+        const filePath = join(dir, 'runtime.json');
+        await writeFile(filePath, '{"profiles":{}}', 'utf8');
+        try {
+            const source = new FileRuntimeConfigSource(filePath);
+            const doc = await source.read();
+            expect(doc.content).toBe('{"profiles":{}}');
+            expect(doc.format).toBe('json');
+            expect(doc.reference).toBe(filePath);
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe('RuntimeConfigLoader.load', () => {
+    it('shoud load a runtime catalog from in-memory json config', async () => {
+        const source = new InMemoryRuntimeConfigSource(JSON.stringify({
+            namedRules: {
+                removeAlways: {
+                    id: RemoveNode.name,
+                    config: { node: { any: true } },
+                },
+            },
+            profiles: {
+                profile: {
+                    phases: [{ phase: 'main', rules: [{ namedRule: 'removeAlways' }] }],
+                },
+            },
+        }));
+        const loader = new RuntimeConfigLoader();
+        const loaded = await loader.load({ source });
+        const phases = loaded.catalog.resolveProfilePhases('profile');
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { any: true } },
+        });
+    });
+    it('shoud load a runtime catalog from in-memory yaml config', async () => {
+        const source = new InMemoryRuntimeConfigSource(`
+namedRules:
+  removeAlways:
+    id: RemoveNode
+    config:
+      node:
+        any: true
+profiles:
+  profile:
+    phases:
+      - phase: main
+        rules:
+          - namedRule: removeAlways
+`, 'yaml');
+        const loader = new RuntimeConfigLoader();
+        const loaded = await loader.load({ source });
+        const phases = loaded.catalog.resolveProfilePhases('profile');
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { any: true } },
+        });
+    });
+    it('shoud fail when runtime config schema validation fails', async () => {
+        const source = new InMemoryRuntimeConfigSource(JSON.stringify({
+            profiles: {
+                profile: {
+                    phases: [{ phase: 'invalid_phase', rules: [] }],
+                },
+            },
+        }));
+        const loader = new RuntimeConfigLoader();
+        await expect(loader.load({ source })).rejects.toThrow(/Runtime config validation failed:/);
+    });
+    it('shoud support custom parsers via dependency injection', async () => {
+        class FakeYamlParser {
+            supports(format) {
+                return format === 'yaml';
+            }
+            parse(_content) {
+                return {
+                    namedRules: {
+                        removeAlways: {
+                            id: RemoveNode.name,
+                            config: { node: { any: true } },
+                        },
+                    },
+                    profiles: {
+                        profile: {
+                            phases: [
+                                { phase: 'main', rules: [{ namedRule: 'removeAlways' }] },
+                            ],
+                        },
+                    },
+                };
+            }
+        }
+        const parserRegistry = new RuntimeConfigParserRegistry([
+            new FakeYamlParser(),
+        ]);
+        const loader = new RuntimeConfigLoader({ parserRegistry });
+        const source = new InMemoryRuntimeConfigSource('profiles:\n  profile: {}', 'yaml');
+        const loaded = await loader.load({ source });
+        const phases = loaded.catalog.resolveProfilePhases('profile');
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { any: true } },
+        });
+    });
+    it('shoud infer the config format from the source reference', async () => {
+        class ReferencedSource {
+            async read() {
+                return {
+                    content: JSON.stringify({
+                        profiles: {
+                            profile: { phases: [] },
+                        },
+                    }),
+                    reference: '/tmp/runtime.json',
+                };
+            }
+        }
+        const loader = new RuntimeConfigLoader();
+        const loaded = await loader.load({ source: new ReferencedSource() });
+        expect(loaded.catalog.resolveProfilePhases('profile')).toEqual([]);
+    });
+    it('shoud fail when source format is unknown', async () => {
+        const source = new InMemoryRuntimeConfigSource('{}', 'custom');
+        const loader = new RuntimeConfigLoader();
+        await expect(loader.load({ source })).rejects.toThrow("Failed to parse runtime config as 'custom': No RuntimeConfigParser registered for format 'custom'");
+    });
+    it('shoud fail when runtime config format cannot be inferred', async () => {
+        class UnknownFormatSource {
+            async read() {
+                return { content: '{}' };
+            }
+        }
+        const source = new UnknownFormatSource();
+        const loader = new RuntimeConfigLoader();
+        await expect(loader.load({ source })).rejects.toThrow('Unable to determine runtime config format');
+    });
+    it('shoud include the source reference when format inference fails', async () => {
+        class UnknownReferencedSource {
+            async read() {
+                return { content: '{}', reference: '/tmp/runtime.unknown' };
+            }
+        }
+        const loader = new RuntimeConfigLoader();
+        await expect(loader.load({ source: new UnknownReferencedSource() })).rejects.toThrow("Unable to determine runtime config format from '/tmp/runtime.unknown'");
+    });
+    it('shoud surface non-error parser failures', async () => {
+        class ThrowingParser {
+            supports(format) {
+                return format === 'json';
+            }
+            parse(_content) {
+                throw 'parser-failed';
+            }
+        }
+        const parserRegistry = new RuntimeConfigParserRegistry([
+            new ThrowingParser(),
+        ]);
+        const loader = new RuntimeConfigLoader({ parserRegistry });
+        const source = new InMemoryRuntimeConfigSource('{}', 'json');
+        await expect(loader.load({ source })).rejects.toThrow("Failed to parse runtime config as 'json': parser-failed");
+    });
+    it('shoud surface non-error validation failures', async () => {
+        const validator = {
+            validate(_input) {
+                throw 'validation-failed';
+            },
+        };
+        const loader = new RuntimeConfigLoader({ validator });
+        const source = new InMemoryRuntimeConfigSource('{}', 'json');
+        await expect(loader.load({ source })).rejects.toThrow('Runtime config validation failed: validation-failed');
+    });
+    it('shoud surface non-error provider load failures', async () => {
+        class ThrowingProviderLoader {
+            async load(_input) {
+                throw 'provider-failed';
+            }
+        }
+        const loader = new RuntimeConfigLoader({
+            providerLoader: new ThrowingProviderLoader(),
+        });
+        const source = new InMemoryRuntimeConfigSource(JSON.stringify({
+            providers: ['@example/runtime-provider'],
+            profiles: {
+                profile: {
+                    phases: [],
+                },
+            },
+        }), 'json');
+        await expect(loader.load({ source })).rejects.toThrow("Failed to load runtime provider '@example/runtime-provider': provider-failed");
+    });
+    it('shoud return validated config alongside catalog with load', async () => {
+        const source = new InMemoryRuntimeConfigSource(JSON.stringify({
+            profiles: {
+                profile: {
+                    phases: [],
+                },
+            },
+            run: {
+                profile: 'profile',
+            },
+        }));
+        const loader = new RuntimeConfigLoader();
+        const loaded = await loader.load({ source });
+        expect(loaded.config.run?.profile).toBe('profile');
+        expect(loaded.catalog.resolveProfilePhases('profile')).toEqual([]);
+    });
+    it('shoud load runtime providers declared in config and merge adapter support registries', async () => {
+        class FakeRuntimeProviderLoader {
+            async load(_input) {
+                return {
+                    supportedAdapterOperationsRegistry: {
+                        ExternalDotAdapter: DotAdapter,
+                    },
+                };
+            }
+        }
+        const source = new InMemoryRuntimeConfigSource(JSON.stringify({
+            providers: ['@example/runtime-provider'],
+            profiles: {
+                profile: {
+                    supports: 'ExternalDotAdapter',
+                    phases: [],
+                },
+            },
+        }), 'json', '/tmp/runtime.json');
+        const loader = new RuntimeConfigLoader({
+            providerLoader: new FakeRuntimeProviderLoader(),
+        });
+        const loaded = await loader.load({ source });
+        const profile = loaded.catalog.resolveProfile('profile');
+        expect(profile.supports).toBe(DotAdapter);
+    });
+    it('shoud merge base provider adapter support registries configured on the loader', async () => {
+        const source = new InMemoryRuntimeConfigSource(JSON.stringify({
+            profiles: {
+                profile: {
+                    supports: 'ExternalDotAdapter',
+                    phases: [],
+                },
+            },
+        }), 'json', '/tmp/runtime.json');
+        const loader = new RuntimeConfigLoader({
+            baseProviders: [
+                {
+                    supportedAdapterOperationsRegistry: {
+                        ExternalDotAdapter: DotAdapter,
+                    },
+                },
+            ],
+        });
+        const loaded = await loader.load({ source });
+        const profile = loaded.catalog.resolveProfile('profile');
+        expect(profile.supports).toBe(DotAdapter);
+    });
+    it('shoud merge provider catalog contributions declared in config', async () => {
+        class FakeRuntimeProviderLoader {
+            async load(_input) {
+                return {
+                    namedRules: new NamedRuleRegistry({
+                        removeAlways: new RemoveNode({
+                            node: { any: true },
+                        }),
+                    }),
+                    namedRuleSets: new NamedRuleSetRegistry({
+                        wrapper: {
+                            rules: [{ namedRule: 'removeAlways' }],
+                        },
+                    }),
+                    profiles: new ProfileRegistry({
+                        'provider.profile': new Profile('provider.profile', {
+                            phases: [{ phase: 'main', rules: [{ namedRuleSet: 'wrapper' }] }],
+                        }),
+                    }),
+                };
+            }
+        }
+        const source = new InMemoryRuntimeConfigSource(JSON.stringify({
+            providers: ['@example/runtime-provider'],
+        }), 'json', '/tmp/runtime.json');
+        const loader = new RuntimeConfigLoader({
+            providerLoader: new FakeRuntimeProviderLoader(),
+        });
+        const loaded = await loader.load({ source });
+        const phases = loaded.catalog.resolveProfilePhases('provider.profile');
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { any: true } },
+        });
+    });
+    it('shoud throw a contextual error when loading a runtime provider fails', async () => {
+        class ThrowingRuntimeProviderLoader {
+            async load(_input) {
+                throw new Error('boom');
+            }
+        }
+        const source = new InMemoryRuntimeConfigSource(JSON.stringify({
+            providers: ['@example/broken-provider'],
+        }), 'json', '/tmp/runtime.json');
+        const loader = new RuntimeConfigLoader({
+            providerLoader: new ThrowingRuntimeProviderLoader(),
+        });
+        await expect(loader.load({ source })).rejects.toThrow("Failed to load runtime provider '@example/broken-provider': boom");
+    });
+});

package/dist/esm/Runtime/RuntimeConfigParser/JsonRuntimeConfigParser.d.ts

@@ -0,0 +1,5 @@
+import { RuntimeConfigParser } from '../RuntimeConfigParser.js';
+export declare class JsonRuntimeConfigParser implements RuntimeConfigParser {
+    supports(format: string): boolean;
+    parse(content: string): unknown;
+}

package/dist/esm/Runtime/RuntimeConfigParser/JsonRuntimeConfigParser.js

@@ -0,0 +1,12 @@
+import { normalizeRuntimeConfigParserFormat, } from '../RuntimeConfigParser.js';
+export class JsonRuntimeConfigParser {
+    supports(format) {
+        const normalized = normalizeRuntimeConfigParserFormat(format);
+        return (normalized === 'json' ||
+            normalized === '.json' ||
+            normalized === 'application/json');
+    }
+    parse(content) {
+        return JSON.parse(content);
+    }
+}

package/dist/esm/Runtime/RuntimeConfigParser/JsonRuntimeConfigParser.test.d.ts

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

package/dist/esm/Runtime/RuntimeConfigParser/JsonRuntimeConfigParser.test.js

@@ -0,0 +1,20 @@
+import { JsonRuntimeConfigParser } from './JsonRuntimeConfigParser.js';
+describe('JsonRuntimeConfigParser.supports', () => {
+    it('shoud support json aliases', () => {
+        const parser = new JsonRuntimeConfigParser();
+        expect(parser.supports('json')).toBe(true);
+        expect(parser.supports('.json')).toBe(true);
+        expect(parser.supports('application/json')).toBe(true);
+        expect(parser.supports('yaml')).toBe(false);
+    });
+});
+describe('JsonRuntimeConfigParser.parse', () => {
+    it('shoud parse json content into an object', () => {
+        const parser = new JsonRuntimeConfigParser();
+        expect(parser.parse('{"value":1}')).toEqual({ value: 1 });
+    });
+    it('shoud throw when json is invalid', () => {
+        const parser = new JsonRuntimeConfigParser();
+        expect(() => parser.parse('{invalid-json')).toThrow();
+    });
+});

package/dist/esm/Runtime/RuntimeConfigParser/YamlRuntimeConfigParser.d.ts

@@ -0,0 +1,5 @@
+import { RuntimeConfigParser } from '../RuntimeConfigParser.js';
+export declare class YamlRuntimeConfigParser implements RuntimeConfigParser {
+    supports(format: string): boolean;
+    parse(content: string): unknown;
+}

package/dist/esm/Runtime/RuntimeConfigParser/YamlRuntimeConfigParser.js

@@ -0,0 +1,16 @@
+import { parse } from 'yaml';
+import { normalizeRuntimeConfigParserFormat, } from '../RuntimeConfigParser.js';
+export class YamlRuntimeConfigParser {
+    supports(format) {
+        const normalized = normalizeRuntimeConfigParserFormat(format);
+        return (normalized === 'yaml' ||
+            normalized === '.yaml' ||
+            normalized === '.yml' ||
+            normalized === 'application/yaml' ||
+            normalized === 'application/x-yaml' ||
+            normalized === 'text/yaml');
+    }
+    parse(content) {
+        return parse(content);
+    }
+}

package/dist/esm/Runtime/RuntimeConfigParser/YamlRuntimeConfigParser.test.d.ts

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

package/dist/esm/Runtime/RuntimeConfigParser/YamlRuntimeConfigParser.test.js

@@ -0,0 +1,29 @@
+import { YamlRuntimeConfigParser } from './YamlRuntimeConfigParser.js';
+describe('YamlRuntimeConfigParser.supports', () => {
+    it('shoud support yaml aliases and mime types', () => {
+        const parser = new YamlRuntimeConfigParser();
+        expect(parser.supports('yaml')).toBe(true);
+        expect(parser.supports('.yaml')).toBe(true);
+        expect(parser.supports('.yml')).toBe(true);
+        expect(parser.supports('application/yaml')).toBe(true);
+        expect(parser.supports('application/x-yaml')).toBe(true);
+        expect(parser.supports('text/yaml')).toBe(true);
+        expect(parser.supports('json')).toBe(false);
+    });
+});
+describe('YamlRuntimeConfigParser.parse', () => {
+    it('shoud parse yaml documents into objects', () => {
+        const parser = new YamlRuntimeConfigParser();
+        expect(parser.parse('profiles:\n  test:\n    phases: []')).toEqual({
+            profiles: {
+                test: {
+                    phases: [],
+                },
+            },
+        });
+    });
+    it('shoud throw when yaml is invalid', () => {
+        const parser = new YamlRuntimeConfigParser();
+        expect(() => parser.parse('profiles: [')).toThrow();
+    });
+});

package/dist/esm/Runtime/RuntimeConfigParser/index.d.ts

@@ -0,0 +1,2 @@
+export * from './JsonRuntimeConfigParser.js';
+export * from './YamlRuntimeConfigParser.js';

package/dist/esm/Runtime/RuntimeConfigParser/index.js

@@ -0,0 +1,2 @@
+export * from './JsonRuntimeConfigParser.js';
+export * from './YamlRuntimeConfigParser.js';

package/dist/esm/Runtime/RuntimeConfigParser.d.ts

@@ -0,0 +1,5 @@
+export interface RuntimeConfigParser {
+    supports(format: string): boolean;
+    parse(content: string): unknown;
+}
+export declare const normalizeRuntimeConfigParserFormat: (format: string) => string;

package/dist/esm/Runtime/RuntimeConfigParser.js

@@ -0,0 +1,2 @@
+import { normalizeRuntimeConfigFormat } from './RuntimeConfigSource.js';
+export const normalizeRuntimeConfigParserFormat = (format) => normalizeRuntimeConfigFormat(format);

package/dist/esm/Runtime/RuntimeConfigParser.test.d.ts

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

package/dist/esm/Runtime/RuntimeConfigParser.test.js

@@ -0,0 +1,6 @@
+import { normalizeRuntimeConfigParserFormat } from './RuntimeConfigParser.js';
+describe('RuntimeConfigParser.normalizeRuntimeConfigParserFormat', () => {
+    it('shoud normalize parser format values by trimming and lowering case', () => {
+        expect(normalizeRuntimeConfigParserFormat('  APPLICATION/JSON  ')).toBe('application/json');
+    });
+});

package/dist/esm/Runtime/RuntimeConfigParserRegistry.d.ts

@@ -0,0 +1,9 @@
+import { RuntimeConfigParser } from './RuntimeConfigParser.js';
+export declare class RuntimeConfigParserRegistry {
+    private readonly parsers;
+    constructor(parsers?: RuntimeConfigParser[]);
+    static defaults(): RuntimeConfigParserRegistry;
+    register(parser: RuntimeConfigParser): RuntimeConfigParserRegistry;
+    use(registry: RuntimeConfigParserRegistry): RuntimeConfigParserRegistry;
+    resolve(format: string): RuntimeConfigParser;
+}

package/dist/esm/Runtime/RuntimeConfigParserRegistry.js

@@ -0,0 +1,32 @@
+import { normalizeRuntimeConfigParserFormat, } from './RuntimeConfigParser.js';
+import { JsonRuntimeConfigParser } from './RuntimeConfigParser/JsonRuntimeConfigParser.js';
+import { YamlRuntimeConfigParser } from './RuntimeConfigParser/YamlRuntimeConfigParser.js';
+export class RuntimeConfigParserRegistry {
+    parsers;
+    constructor(parsers = []) {
+        this.parsers = Object.freeze([...parsers]);
+    }
+    static defaults() {
+        return new RuntimeConfigParserRegistry([
+            new JsonRuntimeConfigParser(),
+            new YamlRuntimeConfigParser(),
+        ]);
+    }
+    register(parser) {
+        return new RuntimeConfigParserRegistry([...this.parsers, parser]);
+    }
+    use(registry) {
+        return new RuntimeConfigParserRegistry([
+            ...this.parsers,
+            ...registry.parsers,
+        ]);
+    }
+    resolve(format) {
+        const normalized = normalizeRuntimeConfigParserFormat(format);
+        const parser = this.parsers.find((candidate) => candidate.supports(normalized));
+        if (!parser) {
+            throw new Error(`No RuntimeConfigParser registered for format '${format}'`);
+        }
+        return parser;
+    }
+}

package/dist/esm/Runtime/RuntimeConfigParserRegistry.test.d.ts

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

package/dist/esm/Runtime/RuntimeConfigParserRegistry.test.js

@@ -0,0 +1,51 @@
+import { RuntimeConfigParserRegistry } from './RuntimeConfigParserRegistry.js';
+class FakeYamlParser {
+    supports(format) {
+        return format === 'yaml';
+    }
+    parse(content) {
+        return { content };
+    }
+}
+describe('RuntimeConfigParserRegistry.defaults', () => {
+    it('shoud include json and yaml parsers by default', () => {
+        const registry = RuntimeConfigParserRegistry.defaults();
+        expect(registry.resolve('json').parse('{"ok":true}')).toEqual({ ok: true });
+        expect(registry.resolve('yaml').parse('value: ok')).toEqual({
+            value: 'ok',
+        });
+    });
+});
+describe('RuntimeConfigParserRegistry.register', () => {
+    it('shoud return a new registry without mutating the original', () => {
+        const base = RuntimeConfigParserRegistry.defaults();
+        const next = base.register(new FakeYamlParser());
+        expect(base.resolve('yaml').parse('value: ok')).toEqual({ value: 'ok' });
+        expect(next.resolve('yaml').parse('value: ok')).toEqual({ value: 'ok' });
+    });
+    it('shoud allow registering parsers on an empty registry', () => {
+        const base = new RuntimeConfigParserRegistry();
+        const next = base.register(new FakeYamlParser());
+        expect(() => base.resolve('yaml')).toThrow("No RuntimeConfigParser registered for format 'yaml'");
+        expect(next.resolve('yaml').parse('value: ok')).toEqual({
+            content: 'value: ok',
+        });
+    });
+});
+describe('RuntimeConfigParserRegistry.use', () => {
+    it('shoud combine parser registries immutably', () => {
+        const one = RuntimeConfigParserRegistry.defaults();
+        const two = new RuntimeConfigParserRegistry([new FakeYamlParser()]);
+        const combined = one.use(two);
+        expect(one.resolve('yaml').parse('value: ok')).toEqual({ value: 'ok' });
+        expect(combined.resolve('yaml').parse('value: ok')).toEqual({
+            value: 'ok',
+        });
+    });
+});
+describe('RuntimeConfigParserRegistry.resolve', () => {
+    it('shoud throw when parser format is not registered', () => {
+        const registry = RuntimeConfigParserRegistry.defaults();
+        expect(() => registry.resolve('toml')).toThrow("No RuntimeConfigParser registered for format 'toml'");
+    });
+});

package/dist/esm/Runtime/RuntimeConfigSource/FileRuntimeConfigSource.d.ts

@@ -0,0 +1,7 @@
+import { RuntimeConfigDocument, RuntimeConfigSource } from '../RuntimeConfigSource.js';
+export declare class FileRuntimeConfigSource implements RuntimeConfigSource {
+    readonly filePath: string;
+    private readonly format?;
+    constructor(filePath: string, format?: string | undefined);
+    read(): Promise<RuntimeConfigDocument>;
+}

package/dist/esm/Runtime/RuntimeConfigSource/FileRuntimeConfigSource.js

@@ -0,0 +1,17 @@
+import { readFile } from 'node:fs/promises';
+import { inferRuntimeConfigFormatFromReference, } from '../RuntimeConfigSource.js';
+export class FileRuntimeConfigSource {
+    filePath;
+    format;
+    constructor(filePath, format) {
+        this.filePath = filePath;
+        this.format = format;
+    }
+    async read() {
+        return {
+            content: await readFile(this.filePath, 'utf8'),
+            format: this.format ?? inferRuntimeConfigFormatFromReference(this.filePath),
+            reference: this.filePath,
+        };
+    }
+}

package/dist/esm/Runtime/RuntimeConfigSource/FileRuntimeConfigSource.test.d.ts

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

package/dist/esm/Runtime/RuntimeConfigSource/FileRuntimeConfigSource.test.js

@@ -0,0 +1,38 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { FileRuntimeConfigSource } from './FileRuntimeConfigSource.js';
+describe('FileRuntimeConfigSource.read', () => {
+    it('shoud infer format from file extension when format is omitted', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'runtime-config-source-file-'));
+        const filePath = join(dir, 'runtime.json');
+        await writeFile(filePath, '{"profiles":{}}', 'utf8');
+        try {
+            const source = new FileRuntimeConfigSource(filePath);
+            await expect(source.read()).resolves.toEqual({
+                content: '{"profiles":{}}',
+                format: 'json',
+                reference: filePath,
+            });
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud prefer explicit format over inferred extension format', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'runtime-config-source-file-'));
+        const filePath = join(dir, 'runtime.json');
+        await writeFile(filePath, 'profiles: {}', 'utf8');
+        try {
+            const source = new FileRuntimeConfigSource(filePath, 'yaml');
+            await expect(source.read()).resolves.toEqual({
+                content: 'profiles: {}',
+                format: 'yaml',
+                reference: filePath,
+            });
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/esm/Runtime/RuntimeConfigSource/InMemoryRuntimeConfigSource.d.ts

@@ -0,0 +1,8 @@
+import { RuntimeConfigDocument, RuntimeConfigSource } from '../RuntimeConfigSource.js';
+export declare class InMemoryRuntimeConfigSource implements RuntimeConfigSource {
+    private readonly content;
+    private readonly format;
+    private readonly reference;
+    constructor(content: string, format?: string, reference?: string);
+    read(): Promise<RuntimeConfigDocument>;
+}