@terra-graph/core 1.0.0-rc.4

package/dist/cjs/Output/ArtifactWriter/StdoutArtifactWriter.test.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_stream_1 = require("node:stream");
+const StdoutArtifactWriter_js_1 = require("./StdoutArtifactWriter.js");
+class CaptureWritable extends node_stream_1.Writable {
+    chunks = [];
+    _write(chunk, _encoding, callback) {
+        if (typeof chunk === 'string') {
+            this.chunks.push(Buffer.from(chunk));
+        }
+        else {
+            this.chunks.push(chunk);
+        }
+        callback();
+    }
+}
+class BackpressureWritable extends node_stream_1.Writable {
+    drainCount = 0;
+    _write(_chunk, _encoding, callback) {
+        callback();
+    }
+    write(chunk, encoding, callback) {
+        if (typeof encoding === 'function') {
+            super.write(chunk, encoding);
+        }
+        else {
+            super.write(chunk, encoding, callback);
+        }
+        setImmediate(() => {
+            this.drainCount += 1;
+            this.emit('drain');
+        });
+        return false;
+    }
+}
+describe('StdoutArtifactWriter.write', () => {
+    it('shoud write artifact content to the configured stream', async () => {
+        const stream = new CaptureWritable();
+        const writer = new StdoutArtifactWriter_js_1.StdoutArtifactWriter(stream);
+        await writer.write({
+            artifact: {
+                content: 'digraph G {}',
+                mediaType: 'text/vnd.graphviz',
+            },
+        });
+        await writer.write({
+            artifact: {
+                content: Buffer.from([1, 2, 3]),
+                mediaType: 'application/octet-stream',
+            },
+        });
+        expect(Buffer.concat(stream.chunks)).toEqual(Buffer.concat([Buffer.from('digraph G {}'), Buffer.from([1, 2, 3])]));
+    });
+    it('shoud wait for drain when backpressure is signaled', async () => {
+        const stream = new BackpressureWritable();
+        const writer = new StdoutArtifactWriter_js_1.StdoutArtifactWriter(stream);
+        await writer.write({
+            artifact: {
+                content: 'digraph G {}',
+                mediaType: 'text/vnd.graphviz',
+            },
+        });
+        expect(stream.drainCount).toBeGreaterThan(0);
+    });
+    it('shoud default to process stdout when no stream is provided', async () => {
+        const originalWrite = process.stdout.write.bind(process.stdout);
+        const writeMock = jest.fn(() => true);
+        process.stdout.write = writeMock;
+        const writer = new StdoutArtifactWriter_js_1.StdoutArtifactWriter();
+        try {
+            await writer.write({
+                artifact: {
+                    content: 'digraph G {}',
+                    mediaType: 'text/vnd.graphviz',
+                },
+            });
+        }
+        finally {
+            process.stdout.write = originalWrite;
+        }
+        expect(writeMock).toHaveBeenCalled();
+    });
+});

package/dist/cjs/Output/ArtifactWriter/index.d.ts

@@ -0,0 +1,2 @@
+export * from './FileArtifactWriter.js';
+export * from './StdoutArtifactWriter.js';

package/dist/cjs/Output/ArtifactWriter/index.js

@@ -0,0 +1,18 @@
+"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("./FileArtifactWriter.js"), exports);
+__exportStar(require("./StdoutArtifactWriter.js"), exports);

package/dist/cjs/Output/ArtifactWriter.d.ts

@@ -0,0 +1,8 @@
+import { RenderArtifact } from '../Graph/Renderer.js';
+export type ArtifactWriteInput = {
+    artifact: RenderArtifact;
+    target?: string;
+};
+export interface ArtifactWriter<TInput extends ArtifactWriteInput = ArtifactWriteInput> {
+    write(input: TInput): Promise<void>;
+}

package/dist/cjs/Output/ArtifactWriter.js

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

package/dist/cjs/Output/RenderPipeline.d.ts

@@ -0,0 +1,12 @@
+import { RenderArtifact } from '../Graph/Renderer.js';
+import { ArtifactTransformer } from './ArtifactTransformer.js';
+import { ArtifactWriteInput, ArtifactWriter } from './ArtifactWriter.js';
+export type RenderPipelineExecuteInput<TWriteInput extends ArtifactWriteInput = ArtifactWriteInput> = {
+    artifact: RenderArtifact;
+    writer: ArtifactWriter<TWriteInput>;
+    write: Omit<TWriteInput, 'artifact'>;
+    transformers?: ArtifactTransformer[];
+};
+export declare class RenderPipeline {
+    execute<TWriteInput extends ArtifactWriteInput = ArtifactWriteInput>(input: RenderPipelineExecuteInput<TWriteInput>): Promise<RenderArtifact>;
+}

package/dist/cjs/Output/RenderPipeline.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderPipeline = void 0;
+class RenderPipeline {
+    async execute(input) {
+        let artifact = input.artifact;
+        for (const transformer of input.transformers ?? []) {
+            artifact = await transformer.transform({ artifact });
+        }
+        await input.writer.write({
+            ...input.write,
+            artifact,
+        });
+        return artifact;
+    }
+}
+exports.RenderPipeline = RenderPipeline;

package/dist/cjs/Output/RenderPipeline.test.d.ts

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

package/dist/cjs/Output/RenderPipeline.test.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RenderPipeline_js_1 = require("./RenderPipeline.js");
+class AppendSuffixTransformer {
+    suffix;
+    constructor(suffix) {
+        this.suffix = suffix;
+    }
+    async transform(input) {
+        if (typeof input.artifact.content !== 'string') {
+            throw new Error('Expected text artifact');
+        }
+        return {
+            ...input.artifact,
+            content: `${input.artifact.content}${this.suffix}`,
+        };
+    }
+}
+class CaptureWriter {
+    lastInput;
+    async write(input) {
+        this.lastInput = input;
+    }
+}
+describe('RenderPipeline.execute', () => {
+    it('shoud apply transformers in order and pass the final artifact to writer', async () => {
+        const pipeline = new RenderPipeline_js_1.RenderPipeline();
+        const writer = new CaptureWriter();
+        const result = await pipeline.execute({
+            artifact: {
+                content: 'base',
+                mediaType: 'text/plain',
+            },
+            transformers: [
+                new AppendSuffixTransformer('-one'),
+                new AppendSuffixTransformer('-two'),
+            ],
+            writer,
+            write: {
+                target: '/tmp/out.txt',
+            },
+        });
+        expect(result).toEqual({
+            content: 'base-one-two',
+            mediaType: 'text/plain',
+        });
+        expect(writer.lastInput).toEqual({
+            target: '/tmp/out.txt',
+            artifact: {
+                content: 'base-one-two',
+                mediaType: 'text/plain',
+            },
+        });
+    });
+    it('shoud write the original artifact when no transformers are provided', async () => {
+        const pipeline = new RenderPipeline_js_1.RenderPipeline();
+        const writer = new CaptureWriter();
+        const result = await pipeline.execute({
+            artifact: {
+                content: 'base',
+                mediaType: 'text/plain',
+            },
+            writer,
+            write: {
+                target: '/tmp/out.txt',
+            },
+        });
+        expect(result).toEqual({
+            content: 'base',
+            mediaType: 'text/plain',
+        });
+        expect(writer.lastInput).toEqual({
+            target: '/tmp/out.txt',
+            artifact: {
+                content: 'base',
+                mediaType: 'text/plain',
+            },
+        });
+    });
+});

package/dist/cjs/Output/index.d.ts

@@ -0,0 +1,7 @@
+export * from './ArtifactTransformer.js';
+export * from './ArtifactTransformer/index.js';
+export * from './ArtifactTransformerFactory.js';
+export * from './ArtifactTransformerFactory/index.js';
+export * from './ArtifactWriter.js';
+export * from './ArtifactWriter/index.js';
+export * from './RenderPipeline.js';

package/dist/cjs/Output/index.js

@@ -0,0 +1,23 @@
+"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("./ArtifactTransformer.js"), exports);
+__exportStar(require("./ArtifactTransformer/index.js"), exports);
+__exportStar(require("./ArtifactTransformerFactory.js"), exports);
+__exportStar(require("./ArtifactTransformerFactory/index.js"), exports);
+__exportStar(require("./ArtifactWriter.js"), exports);
+__exportStar(require("./ArtifactWriter/index.js"), exports);
+__exportStar(require("./RenderPipeline.js"), exports);

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

@@ -0,0 +1,25 @@
+import { GraphPluginRegistry } from '../Graph/GraphPlugin.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 { BaseRule } from '../Graph/Rules/Rule.js';
+export type RuntimeCatalogProvider = {
+    namedRules?: NamedRuleRegistry;
+    namedRuleSets?: NamedRuleSetRegistry;
+    profiles?: ProfileRegistry;
+    plugins?: GraphPluginRegistry;
+};
+export declare class RuntimeCatalog {
+    readonly namedRules: NamedRuleRegistry;
+    readonly namedRuleSets: NamedRuleSetRegistry;
+    readonly profiles: ProfileRegistry;
+    readonly plugins: GraphPluginRegistry;
+    constructor(input?: RuntimeCatalogProvider);
+    static from(providers: RuntimeCatalogProvider[]): RuntimeCatalog;
+    use(provider: RuntimeCatalogProvider): RuntimeCatalog;
+    resolveProfile(name: string): Profile;
+    resolveProfilePhases(name: string): BaseRule[][];
+    resolveProfileRendererOptions<TOptions = Record<string, unknown>>(name: string): TOptions | undefined;
+    resolveProfileRenderer(name: string): string | undefined;
+}

package/dist/cjs/Runtime/RuntimeCatalog.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeCatalog = void 0;
+const GraphPlugin_js_1 = require("../Graph/GraphPlugin.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");
+class RuntimeCatalog {
+    namedRules;
+    namedRuleSets;
+    profiles;
+    plugins;
+    constructor(input = {}) {
+        this.namedRules = input.namedRules ?? new NamedRuleRegistry_js_1.NamedRuleRegistry();
+        this.namedRuleSets = input.namedRuleSets ?? new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry();
+        this.profiles = input.profiles ?? new ProfileRegistry_js_1.ProfileRegistry();
+        this.plugins = input.plugins ?? new GraphPlugin_js_1.GraphPluginRegistry();
+    }
+    static from(providers) {
+        return providers.reduce((combined, provider) => combined.use(provider), new RuntimeCatalog());
+    }
+    use(provider) {
+        return new RuntimeCatalog({
+            namedRules: provider.namedRules
+                ? this.namedRules.use(provider.namedRules)
+                : this.namedRules,
+            namedRuleSets: provider.namedRuleSets
+                ? this.namedRuleSets.use(provider.namedRuleSets)
+                : this.namedRuleSets,
+            profiles: provider.profiles
+                ? this.profiles.use(provider.profiles)
+                : this.profiles,
+            plugins: provider.plugins
+                ? this.plugins.use(provider.plugins)
+                : this.plugins,
+        });
+    }
+    resolveProfile(name) {
+        return this.profiles.resolve(name);
+    }
+    resolveProfilePhases(name) {
+        return this.resolveProfile(name).resolvePhases(this.namedRules, this.namedRuleSets, this.plugins);
+    }
+    resolveProfileRendererOptions(name) {
+        return this.resolveProfile(name).resolveRendererOptions();
+    }
+    resolveProfileRenderer(name) {
+        return this.resolveProfile(name).resolveRenderer();
+    }
+}
+exports.RuntimeCatalog = RuntimeCatalog;

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

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

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

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const GraphPlugin_js_1 = require("../Graph/GraphPlugin.js");
+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");
+describe('RuntimeCatalog.from', () => {
+    it('shoud combine providers into one runtime catalog', () => {
+        const namedRules = new NamedRuleRegistry_js_1.NamedRuleRegistry({
+            ruleOne: new RemoveNode_js_1.RemoveNode({
+                node: { any: true },
+            }),
+        });
+        const namedRuleSets = new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry({
+            setOne: {
+                rules: [{ namedRule: 'ruleOne' }],
+            },
+        });
+        const profiles = new ProfileRegistry_js_1.ProfileRegistry({
+            'example.profile': new Profile_js_1.Profile('example.profile', {}),
+        });
+        class ExamplePlugin extends GraphPlugin_js_1.GraphPlugin {
+            constructor() {
+                super('example.plugin');
+            }
+            build() {
+                return {};
+            }
+        }
+        const plugins = new GraphPlugin_js_1.GraphPluginRegistry({
+            'example.plugin': new ExamplePlugin(),
+        });
+        const catalog = RuntimeCatalog_js_1.RuntimeCatalog.from([
+            { namedRules },
+            { namedRuleSets },
+            { profiles },
+            { plugins },
+        ]);
+        expect(catalog.namedRules.names()).toEqual(['ruleOne']);
+        expect(catalog.namedRuleSets.names()).toEqual(['setOne']);
+        expect(catalog.profiles.names()).toEqual(['example.profile']);
+        expect(catalog.plugins.names()).toEqual(['example.plugin']);
+    });
+    it('shoud prefer later providers when names collide', () => {
+        const first = RuntimeCatalog_js_1.RuntimeCatalog.from([
+            {
+                namedRules: new NamedRuleRegistry_js_1.NamedRuleRegistry({
+                    shared: new RemoveNode_js_1.RemoveNode({
+                        node: { attr: { key: 'label', eq: 'first' } },
+                    }),
+                }),
+            },
+        ]);
+        const second = {
+            namedRules: new NamedRuleRegistry_js_1.NamedRuleRegistry({
+                shared: new RemoveNode_js_1.RemoveNode({
+                    node: { attr: { key: 'label', eq: 'second' } },
+                }),
+            }),
+        };
+        const combined = first.use(second);
+        const resolved = combined.namedRules.resolve('shared');
+        expect(resolved.serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { attr: { key: 'label', eq: 'second' } } },
+        });
+    });
+});
+describe('RuntimeCatalog.resolveProfile', () => {
+    it('shoud resolve a profile by name', () => {
+        const profile = new Profile_js_1.Profile('example.profile', {});
+        const catalog = new RuntimeCatalog_js_1.RuntimeCatalog({
+            profiles: new ProfileRegistry_js_1.ProfileRegistry({
+                'example.profile': profile,
+            }),
+        });
+        expect(catalog.resolveProfile('example.profile')).toBe(profile);
+    });
+});
+describe('RuntimeCatalog.resolveProfilePhases', () => {
+    it('shoud resolve phases using catalog registries', () => {
+        const profile = new Profile_js_1.Profile('example.profile', {
+            phases: [
+                {
+                    phase: 'main',
+                    rules: [{ namedRuleSet: 'wrapper' }],
+                },
+            ],
+        });
+        const catalog = new RuntimeCatalog_js_1.RuntimeCatalog({
+            profiles: new ProfileRegistry_js_1.ProfileRegistry({
+                'example.profile': profile,
+            }),
+            namedRules: new NamedRuleRegistry_js_1.NamedRuleRegistry({
+                removeAlways: new RemoveNode_js_1.RemoveNode({
+                    node: { any: true },
+                }),
+            }),
+            namedRuleSets: new NamedRuleSetRegistry_js_1.NamedRuleSetRegistry({
+                wrapper: {
+                    rules: [{ namedRule: 'removeAlways' }],
+                },
+            }),
+        });
+        const phases = catalog.resolveProfilePhases('example.profile');
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: 'RemoveNode',
+            config: { node: { any: true } },
+        });
+    });
+});
+describe('RuntimeCatalog.resolveProfileRendererOptions', () => {
+    it('shoud resolve renderer options through the profile registry', () => {
+        const profile = new Profile_js_1.Profile('example.profile', {
+            render: {
+                options: {
+                    graph: { rankdir: 'LR' },
+                },
+            },
+        });
+        const catalog = new RuntimeCatalog_js_1.RuntimeCatalog({
+            profiles: new ProfileRegistry_js_1.ProfileRegistry({
+                'example.profile': profile,
+            }),
+        });
+        const options = catalog.resolveProfileRendererOptions('example.profile');
+        expect(options).toEqual({
+            graph: { rankdir: 'LR' },
+        });
+    });
+});
+describe('RuntimeCatalog.resolveProfileRenderer', () => {
+    it('shoud resolve renderer by name through the profile registry', () => {
+        const profile = new Profile_js_1.Profile('example.profile', {
+            render: { renderer: 'dot' },
+        });
+        const catalog = new RuntimeCatalog_js_1.RuntimeCatalog({
+            profiles: new ProfileRegistry_js_1.ProfileRegistry({
+                'example.profile': profile,
+            }),
+        });
+        expect(catalog.resolveProfileRenderer('example.profile')).toBe('dot');
+    });
+});
+describe('RuntimeCatalog.use', () => {
+    it('shoud preserve existing registries when provider omits them', () => {
+        const base = new RuntimeCatalog_js_1.RuntimeCatalog({
+            namedRules: new NamedRuleRegistry_js_1.NamedRuleRegistry({
+                baseRule: new RemoveNode_js_1.RemoveNode({ node: { any: true } }),
+            }),
+        });
+        const updated = base.use({
+            profiles: new ProfileRegistry_js_1.ProfileRegistry({
+                'example.profile': new Profile_js_1.Profile('example.profile', {}),
+            }),
+        });
+        expect(updated.namedRules.names()).toEqual(['baseRule']);
+        expect(updated.profiles.names()).toEqual(['example.profile']);
+    });
+});

package/dist/cjs/Runtime/RuntimeCatalogBuilder/RuntimeCatalogFromConfigBuilder.d.ts

@@ -0,0 +1,5 @@
+import { RuntimeCatalog } from '../RuntimeCatalog.js';
+import { RuntimeCatalogBuildInput, RuntimeCatalogBuilder } from '../RuntimeCatalogBuilder.js';
+export declare class RuntimeCatalogFromConfigBuilder<TOptions extends Record<string, unknown> = Record<string, unknown>> implements RuntimeCatalogBuilder<TOptions> {
+    build(input: RuntimeCatalogBuildInput<TOptions>): RuntimeCatalog;
+}

package/dist/cjs/Runtime/RuntimeCatalogBuilder/RuntimeCatalogFromConfigBuilder.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeCatalogFromConfigBuilder = void 0;
+const RuntimeCatalogLoader_js_1 = require("../RuntimeCatalogLoader.js");
+class RuntimeCatalogFromConfigBuilder {
+    build(input) {
+        return RuntimeCatalogLoader_js_1.RuntimeCatalogLoader.load(input);
+    }
+}
+exports.RuntimeCatalogFromConfigBuilder = RuntimeCatalogFromConfigBuilder;

package/dist/cjs/Runtime/RuntimeCatalogBuilder/RuntimeCatalogFromConfigBuilder.test.d.ts

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

package/dist/cjs/Runtime/RuntimeCatalogBuilder/RuntimeCatalogFromConfigBuilder.test.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RemoveNode_js_1 = require("../../Graph/Rules/Node/RemoveNode.js");
+const RuntimeCatalogFromConfigBuilder_js_1 = require("./RuntimeCatalogFromConfigBuilder.js");
+describe('RuntimeCatalogFromConfigBuilder.build', () => {
+    it('shoud build a runtime catalog from serialized runtime config', () => {
+        const builder = new RuntimeCatalogFromConfigBuilder_js_1.RuntimeCatalogFromConfigBuilder();
+        const catalog = builder.build({
+            config: {
+                namedRules: {
+                    removeAlways: {
+                        id: RemoveNode_js_1.RemoveNode.name,
+                        config: { node: { any: true } },
+                    },
+                },
+                profiles: {
+                    profile: {
+                        phases: [{ phase: 'main', rules: [{ namedRule: 'removeAlways' }] }],
+                    },
+                },
+            },
+        });
+        const phases = catalog.resolveProfilePhases('profile');
+        expect(phases).toHaveLength(1);
+        expect(phases[0]).toHaveLength(1);
+        expect(phases[0][0].serialize()).toEqual({
+            id: RemoveNode_js_1.RemoveNode.name,
+            config: { node: { any: true } },
+        });
+    });
+});

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

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

package/dist/cjs/Runtime/RuntimeCatalogBuilder/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("./RuntimeCatalogFromConfigBuilder.js"), exports);

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

@@ -0,0 +1,11 @@
+import { SupportedAdapterOperationsRegistry } from '../Graph/Serialization/Registry.js';
+import { RuntimeCatalog, RuntimeCatalogProvider } from './RuntimeCatalog.js';
+import { SerializedRuntimeConfig } from './RuntimeCatalogLoader.js';
+export type RuntimeCatalogBuildInput<TOptions extends Record<string, unknown> = Record<string, unknown>> = {
+    providers?: RuntimeCatalogProvider[];
+    config: SerializedRuntimeConfig<TOptions>;
+    supportedAdapterOperationsRegistry?: SupportedAdapterOperationsRegistry;
+};
+export interface RuntimeCatalogBuilder<TOptions extends Record<string, unknown> = Record<string, unknown>> {
+    build(input: RuntimeCatalogBuildInput<TOptions>): RuntimeCatalog;
+}

package/dist/cjs/Runtime/RuntimeCatalogBuilder.js

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

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RuntimeCatalog_js_1 = require("./RuntimeCatalog.js");
+describe('RuntimeCatalogBuilder.build', () => {
+    it('shoud allow implementations to consume runtime build input', () => {
+        class CaptureBuilder {
+            captured;
+            build(input) {
+                this.captured = input;
+                return new RuntimeCatalog_js_1.RuntimeCatalog();
+            }
+        }
+        const builder = new CaptureBuilder();
+        const input = {
+            config: {
+                profiles: {
+                    profile: {
+                        phases: [],
+                    },
+                },
+            },
+        };
+        const catalog = builder.build(input);
+        expect(catalog).toBeInstanceOf(RuntimeCatalog_js_1.RuntimeCatalog);
+        expect(builder.captured).toEqual(input);
+    });
+});