@terra-graph/core 1.0.0-rc.4

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RuntimeConfigParserRegistry_js_1 = require("./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_js_1.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_js_1.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_js_1.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_js_1.RuntimeConfigParserRegistry.defaults();
+        const two = new RuntimeConfigParserRegistry_js_1.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_js_1.RuntimeConfigParserRegistry.defaults();
+        expect(() => registry.resolve('toml')).toThrow("No RuntimeConfigParser registered for format 'toml'");
+    });
+});

package/dist/cjs/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/cjs/Runtime/RuntimeConfigSource/FileRuntimeConfigSource.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileRuntimeConfigSource = void 0;
+const promises_1 = require("node:fs/promises");
+const RuntimeConfigSource_js_1 = require("../RuntimeConfigSource.js");
+class FileRuntimeConfigSource {
+    filePath;
+    format;
+    constructor(filePath, format) {
+        this.filePath = filePath;
+        this.format = format;
+    }
+    async read() {
+        return {
+            content: await (0, promises_1.readFile)(this.filePath, 'utf8'),
+            format: this.format ?? (0, RuntimeConfigSource_js_1.inferRuntimeConfigFormatFromReference)(this.filePath),
+            reference: this.filePath,
+        };
+    }
+}
+exports.FileRuntimeConfigSource = FileRuntimeConfigSource;

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

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

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

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

package/dist/cjs/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>;
+}

package/dist/cjs/Runtime/RuntimeConfigSource/InMemoryRuntimeConfigSource.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryRuntimeConfigSource = void 0;
+class InMemoryRuntimeConfigSource {
+    content;
+    format;
+    reference;
+    constructor(content, format = 'json', reference = 'in-memory') {
+        this.content = content;
+        this.format = format;
+        this.reference = reference;
+    }
+    async read() {
+        return {
+            content: this.content,
+            format: this.format,
+            reference: this.reference,
+        };
+    }
+}
+exports.InMemoryRuntimeConfigSource = InMemoryRuntimeConfigSource;

package/dist/cjs/Runtime/RuntimeConfigSource/InMemoryRuntimeConfigSource.test.d.ts

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

package/dist/cjs/Runtime/RuntimeConfigSource/InMemoryRuntimeConfigSource.test.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const InMemoryRuntimeConfigSource_js_1 = require("./InMemoryRuntimeConfigSource.js");
+describe('InMemoryRuntimeConfigSource.read', () => {
+    it('shoud return default metadata when optional constructor args are omitted', async () => {
+        const source = new InMemoryRuntimeConfigSource_js_1.InMemoryRuntimeConfigSource('{}');
+        await expect(source.read()).resolves.toEqual({
+            content: '{}',
+            format: 'json',
+            reference: 'in-memory',
+        });
+    });
+    it('shoud return provided format and reference metadata', async () => {
+        const source = new InMemoryRuntimeConfigSource_js_1.InMemoryRuntimeConfigSource('{}', 'yaml', 'memory://cfg');
+        await expect(source.read()).resolves.toEqual({
+            content: '{}',
+            format: 'yaml',
+            reference: 'memory://cfg',
+        });
+    });
+});

package/dist/cjs/Runtime/RuntimeConfigSource/YamlRuntimeConfigSource.d.ts

@@ -0,0 +1,6 @@
+import { RuntimeConfigDocument, RuntimeConfigSource } from '../RuntimeConfigSource.js';
+export declare class YamlRuntimeConfigSource implements RuntimeConfigSource {
+    private readonly source;
+    constructor(source: RuntimeConfigSource);
+    read(): Promise<RuntimeConfigDocument>;
+}

package/dist/cjs/Runtime/RuntimeConfigSource/YamlRuntimeConfigSource.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YamlRuntimeConfigSource = void 0;
+class YamlRuntimeConfigSource {
+    source;
+    constructor(source) {
+        this.source = source;
+    }
+    async read() {
+        const document = await this.source.read();
+        return {
+            ...document,
+            format: 'yaml',
+        };
+    }
+}
+exports.YamlRuntimeConfigSource = YamlRuntimeConfigSource;

package/dist/cjs/Runtime/RuntimeConfigSource/YamlRuntimeConfigSource.test.d.ts

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

package/dist/cjs/Runtime/RuntimeConfigSource/YamlRuntimeConfigSource.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const YamlRuntimeConfigSource_js_1 = require("./YamlRuntimeConfigSource.js");
+class FakeRuntimeConfigSource {
+    document;
+    constructor(document) {
+        this.document = document;
+    }
+    async read() {
+        return this.document;
+    }
+}
+describe('YamlRuntimeConfigSource.read', () => {
+    it('shoud force the format to yaml while preserving content and reference', async () => {
+        const source = new YamlRuntimeConfigSource_js_1.YamlRuntimeConfigSource(new FakeRuntimeConfigSource({
+            content: 'profiles:\n  test: {}',
+            format: 'json',
+            reference: '/tmp/config.any',
+        }));
+        await expect(source.read()).resolves.toEqual({
+            content: 'profiles:\n  test: {}',
+            format: 'yaml',
+            reference: '/tmp/config.any',
+        });
+    });
+    it('shoud set yaml format when source format is missing', async () => {
+        const source = new YamlRuntimeConfigSource_js_1.YamlRuntimeConfigSource(new FakeRuntimeConfigSource({
+            content: 'profiles:\n  test: {}',
+            reference: 'memory://yaml',
+        }));
+        await expect(source.read()).resolves.toEqual({
+            content: 'profiles:\n  test: {}',
+            format: 'yaml',
+            reference: 'memory://yaml',
+        });
+    });
+});

package/dist/cjs/Runtime/RuntimeConfigSource/index.d.ts

@@ -0,0 +1,3 @@
+export * from './FileRuntimeConfigSource.js';
+export * from './InMemoryRuntimeConfigSource.js';
+export * from './YamlRuntimeConfigSource.js';

package/dist/cjs/Runtime/RuntimeConfigSource/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./FileRuntimeConfigSource.js"), exports);
+__exportStar(require("./InMemoryRuntimeConfigSource.js"), exports);
+__exportStar(require("./YamlRuntimeConfigSource.js"), exports);

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

@@ -0,0 +1,10 @@
+export type RuntimeConfigDocument = {
+    content: string;
+    format?: string;
+    reference?: string;
+};
+export interface RuntimeConfigSource {
+    read(): Promise<RuntimeConfigDocument>;
+}
+export declare const normalizeRuntimeConfigFormat: (format: string) => string;
+export declare const inferRuntimeConfigFormatFromReference: (reference: string | undefined) => string | undefined;

package/dist/cjs/Runtime/RuntimeConfigSource.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferRuntimeConfigFormatFromReference = exports.normalizeRuntimeConfigFormat = void 0;
+const node_path_1 = require("node:path");
+const normalizeRuntimeConfigFormat = (format) => format.trim().toLowerCase();
+exports.normalizeRuntimeConfigFormat = normalizeRuntimeConfigFormat;
+const inferRuntimeConfigFormatFromReference = (reference) => {
+    if (!reference) {
+        return undefined;
+    }
+    const extension = (0, exports.normalizeRuntimeConfigFormat)((0, node_path_1.extname)(reference));
+    if (extension === '.json') {
+        return 'json';
+    }
+    if (extension === '.yaml' || extension === '.yml') {
+        return 'yaml';
+    }
+    return undefined;
+};
+exports.inferRuntimeConfigFormatFromReference = inferRuntimeConfigFormatFromReference;

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

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

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RuntimeConfigSource_js_1 = require("./RuntimeConfigSource.js");
+describe('RuntimeConfigSource.normalizeRuntimeConfigFormat', () => {
+    it('shoud normalize format strings by trimming and lowering case', () => {
+        expect((0, RuntimeConfigSource_js_1.normalizeRuntimeConfigFormat)('  JSON  ')).toBe('json');
+    });
+});
+describe('RuntimeConfigSource.inferRuntimeConfigFormatFromReference', () => {
+    it('shoud infer json from file extension', () => {
+        expect((0, RuntimeConfigSource_js_1.inferRuntimeConfigFormatFromReference)('/tmp/config.JSON')).toBe('json');
+    });
+    it('shoud infer yaml from file extensions', () => {
+        expect((0, RuntimeConfigSource_js_1.inferRuntimeConfigFormatFromReference)('/tmp/config.yaml')).toBe('yaml');
+        expect((0, RuntimeConfigSource_js_1.inferRuntimeConfigFormatFromReference)('/tmp/config.yml')).toBe('yaml');
+    });
+    it('shoud return undefined for unknown extensions', () => {
+        expect((0, RuntimeConfigSource_js_1.inferRuntimeConfigFormatFromReference)('/tmp/config.toml')).toBe(undefined);
+    });
+    it('shoud return undefined for missing references', () => {
+        expect((0, RuntimeConfigSource_js_1.inferRuntimeConfigFormatFromReference)(undefined)).toBe(undefined);
+    });
+});

package/dist/cjs/Runtime/RuntimeConfigValidator/ZodRuntimeConfigValidator.d.ts

@@ -0,0 +1,5 @@
+import { SerializedRuntimeConfig } from '../RuntimeCatalogLoader.js';
+import { RuntimeConfigValidator } from '../RuntimeConfigValidator.js';
+export declare class ZodRuntimeConfigValidator<TOptions extends Record<string, unknown> = Record<string, unknown>> implements RuntimeConfigValidator<TOptions> {
+    validate(input: unknown): SerializedRuntimeConfig<TOptions>;
+}

package/dist/cjs/Runtime/RuntimeConfigValidator/ZodRuntimeConfigValidator.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodRuntimeConfigValidator = void 0;
+const zod_1 = require("zod");
+const RulePlan_js_1 = require("../../Graph/Rules/RulePlan.js");
+const namedRuleRefSchema = zod_1.z.object({ namedRule: zod_1.z.string().min(1) }).strict();
+const namedRuleSetRefSchema = zod_1.z
+    .object({
+    namedRuleSet: zod_1.z.string().min(1),
+})
+    .strict();
+const serializedRuleSchema = zod_1.z
+    .object({
+    id: zod_1.z.string().min(1),
+    config: zod_1.z.object({}).passthrough(),
+})
+    .strict();
+const phaseRuleSchema = zod_1.z.union([
+    serializedRuleSchema,
+    namedRuleRefSchema,
+    namedRuleSetRefSchema,
+]);
+const namedPhaseSchema = zod_1.z.enum(RulePlan_js_1.NAMED_PHASES);
+const phasePlanSchema = zod_1.z.array(zod_1.z
+    .object({
+    phase: namedPhaseSchema,
+    rules: zod_1.z.array(phaseRuleSchema),
+})
+    .strict());
+const renderSchema = zod_1.z
+    .object({
+    renderer: zod_1.z.string().min(1).optional(),
+    options: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+})
+    .strict();
+const pluginRefSchema = zod_1.z
+    .object({
+    plugin: zod_1.z.string().min(1),
+    options: zod_1.z.unknown().optional(),
+})
+    .strict();
+const serializedRuntimeProfileSchema = zod_1.z
+    .object({
+    supports: zod_1.z.string().min(1).optional(),
+    render: renderSchema.optional(),
+    phases: phasePlanSchema.optional(),
+    plugins: zod_1.z.array(pluginRefSchema).optional(),
+    usesProfiles: zod_1.z.array(zod_1.z.string().min(1)).optional(),
+})
+    .strict();
+const serializedRuleSetSchema = zod_1.z
+    .object({
+    name: zod_1.z.string().optional(),
+    rules: zod_1.z.array(phaseRuleSchema).optional(),
+})
+    .strict();
+const serializedRuntimeConfigSchema = zod_1.z
+    .object({
+    providers: zod_1.z.array(zod_1.z.string().min(1)).optional(),
+    namedRules: zod_1.z.record(zod_1.z.string(), serializedRuleSchema).optional(),
+    namedRuleSets: zod_1.z.record(zod_1.z.string(), serializedRuleSetSchema).optional(),
+    profiles: zod_1.z.record(zod_1.z.string(), serializedRuntimeProfileSchema).optional(),
+    run: zod_1.z
+        .object({
+        profile: zod_1.z.string().min(1),
+        render: renderSchema.optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+class ZodRuntimeConfigValidator {
+    validate(input) {
+        return serializedRuntimeConfigSchema.parse(input);
+    }
+}
+exports.ZodRuntimeConfigValidator = ZodRuntimeConfigValidator;

package/dist/cjs/Runtime/RuntimeConfigValidator/ZodRuntimeConfigValidator.test.d.ts

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

package/dist/cjs/Runtime/RuntimeConfigValidator/ZodRuntimeConfigValidator.test.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RemoveNode_js_1 = require("../../Graph/Rules/Node/RemoveNode.js");
+const ZodRuntimeConfigValidator_js_1 = require("./ZodRuntimeConfigValidator.js");
+describe('ZodRuntimeConfigValidator.validate', () => {
+    it('shoud validate and return serialized runtime config', () => {
+        const validator = new ZodRuntimeConfigValidator_js_1.ZodRuntimeConfigValidator();
+        const result = validator.validate({
+            providers: ['@acme/terra-provider'],
+            namedRules: {
+                removeAlways: {
+                    id: RemoveNode_js_1.RemoveNode.name,
+                    config: { node: { any: true } },
+                },
+            },
+            profiles: {
+                profile: {
+                    phases: [{ phase: 'main', rules: [{ namedRule: 'removeAlways' }] }],
+                },
+            },
+        });
+        expect(result.profiles?.profile.phases).toHaveLength(1);
+        expect(result.providers).toEqual(['@acme/terra-provider']);
+    });
+    it('shoud throw when serialized runtime config is invalid', () => {
+        const validator = new ZodRuntimeConfigValidator_js_1.ZodRuntimeConfigValidator();
+        expect(() => validator.validate({
+            profiles: {
+                profile: {
+                    phases: [{ phase: 'invalid_phase', rules: [] }],
+                },
+            },
+        })).toThrow();
+    });
+    it('shoud allow unknown profile references in usesProfiles', () => {
+        const validator = new ZodRuntimeConfigValidator_js_1.ZodRuntimeConfigValidator();
+        const result = validator.validate({
+            profiles: {
+                child: {
+                    usesProfiles: ['missing'],
+                    phases: [],
+                },
+            },
+        });
+        expect(result.profiles?.child.usesProfiles).toEqual(['missing']);
+    });
+    it('shoud accept profiles that reference known parents', () => {
+        const validator = new ZodRuntimeConfigValidator_js_1.ZodRuntimeConfigValidator();
+        const result = validator.validate({
+            profiles: {
+                base: {
+                    phases: [],
+                },
+                child: {
+                    usesProfiles: ['base'],
+                    phases: [],
+                },
+            },
+        });
+        expect(result.profiles?.child.usesProfiles).toEqual(['base']);
+    });
+});

package/dist/cjs/Runtime/RuntimeConfigValidator/index.d.ts

@@ -0,0 +1 @@
+export * from './ZodRuntimeConfigValidator.js';

package/dist/cjs/Runtime/RuntimeConfigValidator/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ZodRuntimeConfigValidator.js"), exports);

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

@@ -0,0 +1,4 @@
+import { SerializedRuntimeConfig } from './RuntimeCatalogLoader.js';
+export interface RuntimeConfigValidator<TOptions extends Record<string, unknown> = Record<string, unknown>> {
+    validate(input: unknown): SerializedRuntimeConfig<TOptions>;
+}

package/dist/cjs/Runtime/RuntimeConfigValidator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+describe('RuntimeConfigValidator.validate', () => {
+    it('shoud allow implementations to return serialized runtime config', () => {
+        class PassthroughValidator {
+            validate(input) {
+                return input;
+            }
+        }
+        const validator = new PassthroughValidator();
+        const input = {
+            profiles: {
+                profile: {
+                    phases: [],
+                },
+            },
+        };
+        expect(validator.validate(input)).toEqual(input);
+    });
+    it('shoud allow implementations to throw validation errors', () => {
+        class ThrowingValidator {
+            validate(_input) {
+                throw new Error('invalid-runtime-config');
+                // Unreachable return keeps the method aligned with the contract type.
+                // biome-ignore lint/correctness/noUnreachable: <explanation>
+                return {
+                    profiles: {},
+                };
+            }
+        }
+        const validator = new ThrowingValidator();
+        expect(() => validator.validate({
+            profiles: {
+                profile: {
+                    phases: [],
+                },
+            },
+        })).toThrow('invalid-runtime-config');
+    });
+});

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

@@ -0,0 +1,5 @@
+import { SupportedAdapterOperationsRegistry } from '../Graph/Serialization/Registry.js';
+import { RuntimeCatalogProvider } from './RuntimeCatalog.js';
+export type RuntimeProvider = RuntimeCatalogProvider & {
+    supportedAdapterOperationsRegistry?: SupportedAdapterOperationsRegistry;
+};

package/dist/cjs/Runtime/RuntimeProvider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+describe('RuntimeProvider', () => {
+    it('shoud allow catalog and adapter contributions in one object', () => {
+        const provider = {
+            supportedAdapterOperationsRegistry: {},
+        };
+        expect(provider).toEqual({
+            supportedAdapterOperationsRegistry: {},
+        });
+    });
+});

package/dist/cjs/Runtime/RuntimeProviderLoader/ModuleRuntimeProviderLoader.d.ts

@@ -0,0 +1,14 @@
+import { RuntimeProvider } from '../RuntimeProvider.js';
+import { RuntimeProviderLoadInput, RuntimeProviderLoader } from '../RuntimeProviderLoader.js';
+type RuntimeProviderModuleShape = RuntimeProvider | (() => RuntimeProvider | Promise<RuntimeProvider>) | {
+    runtimeProvider?: RuntimeProvider | (() => RuntimeProvider | Promise<RuntimeProvider>);
+    default?: RuntimeProvider | (() => RuntimeProvider | Promise<RuntimeProvider>);
+};
+export declare const __test__: {
+    toProvider: (value: RuntimeProviderModuleShape) => Promise<RuntimeProvider>;
+    resolveImportSpecifier: (specifier: string, sourceReference?: string) => string;
+};
+export declare class ModuleRuntimeProviderLoader implements RuntimeProviderLoader {
+    load(input: RuntimeProviderLoadInput): Promise<RuntimeProvider>;
+}
+export {};