@terra-graph/core 1.0.0-rc.4

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

@@ -0,0 +1,17 @@
+export 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,
+        };
+    }
+}

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

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

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

@@ -0,0 +1,19 @@
+import { InMemoryRuntimeConfigSource } from './InMemoryRuntimeConfigSource.js';
+describe('InMemoryRuntimeConfigSource.read', () => {
+    it('shoud return default metadata when optional constructor args are omitted', async () => {
+        const source = new 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('{}', 'yaml', 'memory://cfg');
+        await expect(source.read()).resolves.toEqual({
+            content: '{}',
+            format: 'yaml',
+            reference: 'memory://cfg',
+        });
+    });
+});

package/dist/esm/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/esm/Runtime/RuntimeConfigSource/YamlRuntimeConfigSource.js

@@ -0,0 +1,13 @@
+export class YamlRuntimeConfigSource {
+    source;
+    constructor(source) {
+        this.source = source;
+    }
+    async read() {
+        const document = await this.source.read();
+        return {
+            ...document,
+            format: 'yaml',
+        };
+    }
+}

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

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

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

@@ -0,0 +1,35 @@
+import { YamlRuntimeConfigSource } from './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(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(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/esm/Runtime/RuntimeConfigSource/index.d.ts

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

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

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

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

@@ -0,0 +1,15 @@
+import { extname } from 'node:path';
+export const normalizeRuntimeConfigFormat = (format) => format.trim().toLowerCase();
+export const inferRuntimeConfigFormatFromReference = (reference) => {
+    if (!reference) {
+        return undefined;
+    }
+    const extension = normalizeRuntimeConfigFormat(extname(reference));
+    if (extension === '.json') {
+        return 'json';
+    }
+    if (extension === '.yaml' || extension === '.yml') {
+        return 'yaml';
+    }
+    return undefined;
+};

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

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

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

@@ -0,0 +1,21 @@
+import { inferRuntimeConfigFormatFromReference, normalizeRuntimeConfigFormat, } from './RuntimeConfigSource.js';
+describe('RuntimeConfigSource.normalizeRuntimeConfigFormat', () => {
+    it('shoud normalize format strings by trimming and lowering case', () => {
+        expect(normalizeRuntimeConfigFormat('  JSON  ')).toBe('json');
+    });
+});
+describe('RuntimeConfigSource.inferRuntimeConfigFormatFromReference', () => {
+    it('shoud infer json from file extension', () => {
+        expect(inferRuntimeConfigFormatFromReference('/tmp/config.JSON')).toBe('json');
+    });
+    it('shoud infer yaml from file extensions', () => {
+        expect(inferRuntimeConfigFormatFromReference('/tmp/config.yaml')).toBe('yaml');
+        expect(inferRuntimeConfigFormatFromReference('/tmp/config.yml')).toBe('yaml');
+    });
+    it('shoud return undefined for unknown extensions', () => {
+        expect(inferRuntimeConfigFormatFromReference('/tmp/config.toml')).toBe(undefined);
+    });
+    it('shoud return undefined for missing references', () => {
+        expect(inferRuntimeConfigFormatFromReference(undefined)).toBe(undefined);
+    });
+});

package/dist/esm/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/esm/Runtime/RuntimeConfigValidator/ZodRuntimeConfigValidator.js

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

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

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

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

@@ -0,0 +1,60 @@
+import { RemoveNode } from '../../Graph/Rules/Node/RemoveNode.js';
+import { ZodRuntimeConfigValidator } from './ZodRuntimeConfigValidator.js';
+describe('ZodRuntimeConfigValidator.validate', () => {
+    it('shoud validate and return serialized runtime config', () => {
+        const validator = new ZodRuntimeConfigValidator();
+        const result = validator.validate({
+            providers: ['@acme/terra-provider'],
+            namedRules: {
+                removeAlways: {
+                    id: 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();
+        expect(() => validator.validate({
+            profiles: {
+                profile: {
+                    phases: [{ phase: 'invalid_phase', rules: [] }],
+                },
+            },
+        })).toThrow();
+    });
+    it('shoud allow unknown profile references in usesProfiles', () => {
+        const validator = new 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();
+        const result = validator.validate({
+            profiles: {
+                base: {
+                    phases: [],
+                },
+                child: {
+                    usesProfiles: ['base'],
+                    phases: [],
+                },
+            },
+        });
+        expect(result.profiles?.child.usesProfiles).toEqual(['base']);
+    });
+});

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

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

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

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

package/dist/esm/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/esm/Runtime/RuntimeConfigValidator.js

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

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

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

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

@@ -0,0 +1,39 @@
+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');
+    });
+});
+export {};

package/dist/esm/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/esm/Runtime/RuntimeProvider.js

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

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

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

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

@@ -0,0 +1,11 @@
+describe('RuntimeProvider', () => {
+    it('shoud allow catalog and adapter contributions in one object', () => {
+        const provider = {
+            supportedAdapterOperationsRegistry: {},
+        };
+        expect(provider).toEqual({
+            supportedAdapterOperationsRegistry: {},
+        });
+    });
+});
+export {};

package/dist/esm/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 {};

package/dist/esm/Runtime/RuntimeProviderLoader/ModuleRuntimeProviderLoader.js

@@ -0,0 +1,50 @@
+import { dirname, isAbsolute, resolve as resolvePath } from 'node:path';
+import { pathToFileURL } from 'node:url';
+const isRuntimeProvider = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isRuntimeProviderFactory = (value) => typeof value === 'function';
+const toProvider = async (value) => {
+    const candidate = isRuntimeProvider(value) &&
+        ('runtimeProvider' in value || 'default' in value)
+        ? (value.runtimeProvider ??
+            value.default)
+        : value;
+    if (isRuntimeProviderFactory(candidate)) {
+        const resolved = await candidate();
+        if (!isRuntimeProvider(resolved)) {
+            throw new Error('Module does not export a valid runtime provider');
+        }
+        return resolved;
+    }
+    if (!isRuntimeProvider(candidate)) {
+        throw new Error('Module does not export a valid runtime provider');
+    }
+    return candidate;
+};
+const resolveImportSpecifier = (specifier, sourceReference) => {
+    if (specifier.startsWith('.') ||
+        specifier.startsWith('/') ||
+        specifier.startsWith('file:')) {
+        if (specifier.startsWith('file:')) {
+            return specifier;
+        }
+        if (isAbsolute(specifier)) {
+            return pathToFileURL(specifier).href;
+        }
+        if (!sourceReference) {
+            return pathToFileURL(resolvePath(specifier)).href;
+        }
+        return pathToFileURL(resolvePath(dirname(sourceReference), specifier)).href;
+    }
+    return specifier;
+};
+export const __test__ = {
+    toProvider,
+    resolveImportSpecifier,
+};
+export class ModuleRuntimeProviderLoader {
+    async load(input) {
+        const resolvedSpecifier = resolveImportSpecifier(input.specifier, input.sourceReference);
+        const loaded = await import(resolvedSpecifier);
+        return toProvider(loaded);
+    }
+}

package/dist/esm/Runtime/RuntimeProviderLoader/ModuleRuntimeProviderLoader.test.d.ts

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

package/dist/esm/Runtime/RuntimeProviderLoader/ModuleRuntimeProviderLoader.test.js

@@ -0,0 +1,146 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ModuleRuntimeProviderLoader, __test__, } from './ModuleRuntimeProviderLoader.js';
+describe('ModuleRuntimeProviderLoader.load', () => {
+    it('shoud load a provider from a module default object export', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'runtime-provider-loader-'));
+        const providerPath = join(dir, 'provider.cjs');
+        await writeFile(providerPath, 'module.exports = { supportedAdapterOperationsRegistry: { ExternalAdapter: class ExternalAdapter {} } };', 'utf8');
+        try {
+            const loader = new ModuleRuntimeProviderLoader();
+            const provider = await loader.load({ specifier: providerPath });
+            expect(provider.supportedAdapterOperationsRegistry).toBeDefined();
+            expect(provider.supportedAdapterOperationsRegistry
+                ? Object.keys(provider.supportedAdapterOperationsRegistry)
+                : []).toContain('ExternalAdapter');
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud load a provider from a runtimeProvider named export', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'runtime-provider-loader-'));
+        const providerPath = join(dir, 'provider.cjs');
+        await writeFile(providerPath, 'module.exports = { runtimeProvider: { supportedAdapterOperationsRegistry: { NamedExport: class NamedExport {} } } };', 'utf8');
+        try {
+            const loader = new ModuleRuntimeProviderLoader();
+            const provider = await loader.load({ specifier: providerPath });
+            expect(provider.supportedAdapterOperationsRegistry).toBeDefined();
+            expect(provider.supportedAdapterOperationsRegistry
+                ? Object.keys(provider.supportedAdapterOperationsRegistry)
+                : []).toContain('NamedExport');
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud accept raw runtime providers without module export markers', async () => {
+        const provider = {};
+        await expect(__test__.toProvider(provider)).resolves.toBe(provider);
+    });
+    it('shoud load a provider from a default function export', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'runtime-provider-loader-'));
+        const providerPath = join(dir, 'provider.cjs');
+        await writeFile(providerPath, 'module.exports = () => ({ supportedAdapterOperationsRegistry: { FromDefault: class FromDefault {} } });', 'utf8');
+        try {
+            const loader = new ModuleRuntimeProviderLoader();
+            const provider = await loader.load({ specifier: providerPath });
+            expect(provider.supportedAdapterOperationsRegistry).toBeDefined();
+            expect(provider.supportedAdapterOperationsRegistry
+                ? Object.keys(provider.supportedAdapterOperationsRegistry)
+                : []).toContain('FromDefault');
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud load a provider from a file URL specifier', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'runtime-provider-loader-'));
+        const providerPath = join(dir, 'provider.cjs');
+        await writeFile(providerPath, 'module.exports = { supportedAdapterOperationsRegistry: { FileUrlProvider: class FileUrlProvider {} } };', 'utf8');
+        try {
+            const loader = new ModuleRuntimeProviderLoader();
+            const provider = await loader.load({
+                specifier: pathToFileURL(providerPath).href,
+            });
+            expect(provider.supportedAdapterOperationsRegistry).toBeDefined();
+            expect(provider.supportedAdapterOperationsRegistry
+                ? Object.keys(provider.supportedAdapterOperationsRegistry)
+                : []).toContain('FileUrlProvider');
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud resolve relative provider specifiers from cwd when no reference is provided', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'runtime-provider-loader-'));
+        const providerPath = join(dir, 'provider.cjs');
+        const originalCwd = process.cwd();
+        await writeFile(providerPath, 'module.exports = { supportedAdapterOperationsRegistry: { CwdProvider: class CwdProvider {} } };', 'utf8');
+        try {
+            process.chdir(dir);
+            const loader = new ModuleRuntimeProviderLoader();
+            const provider = await loader.load({ specifier: './provider.cjs' });
+            expect(provider.supportedAdapterOperationsRegistry).toBeDefined();
+            expect(provider.supportedAdapterOperationsRegistry
+                ? Object.keys(provider.supportedAdapterOperationsRegistry)
+                : []).toContain('CwdProvider');
+        }
+        finally {
+            process.chdir(originalCwd);
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud resolve relative provider specifiers from sourceReference', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'runtime-provider-loader-'));
+        const configPath = join(dir, 'runtime.yaml');
+        const providerPath = join(dir, 'provider.cjs');
+        await writeFile(providerPath, 'module.exports = { supportedAdapterOperationsRegistry: { RelativeProvider: class RelativeProvider {} } };', 'utf8');
+        try {
+            const loader = new ModuleRuntimeProviderLoader();
+            const provider = await loader.load({
+                specifier: './provider.cjs',
+                sourceReference: configPath,
+            });
+            expect(provider.supportedAdapterOperationsRegistry).toBeDefined();
+            expect(provider.supportedAdapterOperationsRegistry
+                ? Object.keys(provider.supportedAdapterOperationsRegistry)
+                : []).toContain('RelativeProvider');
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud accept non-file specifiers unchanged', async () => {
+        const loader = new ModuleRuntimeProviderLoader();
+        const provider = await loader.load({ specifier: 'node:fs' });
+        expect(provider).toBeDefined();
+        expect(provider.readFile).toBeDefined();
+    });
+    it('shoud throw when module does not export a runtime provider', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'runtime-provider-loader-'));
+        const providerPath = join(dir, 'provider.cjs');
+        await writeFile(providerPath, 'module.exports = 1;', 'utf8');
+        try {
+            const loader = new ModuleRuntimeProviderLoader();
+            await expect(loader.load({ specifier: providerPath })).rejects.toThrow('Module does not export a valid runtime provider');
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+    it('shoud throw when a provider factory resolves to an invalid value', async () => {
+        const dir = await mkdtemp(join(tmpdir(), 'runtime-provider-loader-'));
+        const providerPath = join(dir, 'provider.cjs');
+        await writeFile(providerPath, 'module.exports = { runtimeProvider: () => 1 };', 'utf8');
+        try {
+            const loader = new ModuleRuntimeProviderLoader();
+            await expect(loader.load({ specifier: providerPath })).rejects.toThrow('Module does not export a valid runtime provider');
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    });
+});

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { RuntimeProvider } from './RuntimeProvider.js';
+export type RuntimeProviderLoadInput = {
+    specifier: string;
+    sourceReference?: string;
+};
+export interface RuntimeProviderLoader {
+    load(input: RuntimeProviderLoadInput): Promise<RuntimeProvider>;
+}

package/dist/esm/Runtime/RuntimeProviderLoader.js

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

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

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