@alpic80/rivet-core 1.19.1-aidon.1

package/dist/types/model/DataValue.d.ts

@@ -0,0 +1,138 @@
+import type { GraphId } from '../index.js';
+import type { DataId } from './Project.js';
+export type DataValueDef<Type extends string, RuntimeType> = {
+    type: Type;
+    value: RuntimeType;
+};
+export type StringDataValue = DataValueDef<'string', string>;
+export type NumberDataValue = DataValueDef<'number', number>;
+export type BoolDataValue = DataValueDef<'boolean', boolean>;
+export type SystemChatMessage = {
+    type: 'system';
+    message: ChatMessageMessagePart | ChatMessageMessagePart[];
+};
+export type UserChatMessage = {
+    type: 'user';
+    message: ChatMessageMessagePart | ChatMessageMessagePart[];
+};
+export type AssistantChatMessageFunctionCall = {
+    id: string | undefined;
+    name: string;
+    arguments: string;
+};
+export type ParsedAssistantChatMessageFunctionCall = {
+    id: string | undefined;
+    name: string;
+    arguments: Record<string, unknown>;
+};
+export type AssistantChatMessage = {
+    type: 'assistant';
+    message: ChatMessageMessagePart | ChatMessageMessagePart[];
+    /** @deprecated use function_calls instead */
+    function_call: AssistantChatMessageFunctionCall | undefined;
+    function_calls: AssistantChatMessageFunctionCall[] | undefined;
+};
+export type FunctionResponseChatMessage = {
+    type: 'function';
+    message: ChatMessageMessagePart | ChatMessageMessagePart[];
+    name: string;
+};
+export type ChatMessage = SystemChatMessage | UserChatMessage | AssistantChatMessage | FunctionResponseChatMessage;
+export type ChatMessageMessagePart = string | {
+    type: 'image';
+    mediaType: SupportedMediaTypes;
+    data: Uint8Array;
+} | {
+    type: 'url';
+    url: string;
+};
+export type SupportedMediaTypes = 'image/jpeg' | 'image/png' | 'image/gif';
+export type ChatMessageDataValue = DataValueDef<'chat-message', ChatMessage>;
+export type DateDataValue = DataValueDef<'date', string>;
+export type TimeDataValue = DataValueDef<'time', string>;
+export type DateTimeDataValue = DataValueDef<'datetime', string>;
+export type AnyDataValue = DataValueDef<'any', unknown>;
+export type ObjectDataValue = DataValueDef<'object', Record<string, unknown>>;
+export type VectorDataValue = DataValueDef<'vector', number[]>;
+export type BinaryDataValue = DataValueDef<'binary', Uint8Array>;
+export type ImageDataValue = DataValueDef<'image', {
+    mediaType: SupportedMediaTypes;
+    data: Uint8Array;
+}>;
+export type AudioDataValue = DataValueDef<'audio', {
+    mediaType?: string;
+    data: Uint8Array;
+}>;
+export type GraphReferenceValue = DataValueDef<'graph-reference', {
+    graphId: GraphId;
+    graphName: string;
+}>;
+/** GPT function definition */
+export type GptFunction = {
+    name: string;
+    namespace?: string;
+    description: string;
+    parameters: object;
+    strict: boolean;
+};
+export type GptFunctionDataValue = DataValueDef<'gpt-function', GptFunction>;
+export type ControlFlowExcludedDataValue = DataValueDef<'control-flow-excluded', undefined | 'loop-not-broken'>;
+export type ScalarDataValue = StringDataValue | NumberDataValue | DateDataValue | TimeDataValue | DateTimeDataValue | BoolDataValue | ChatMessageDataValue | ControlFlowExcludedDataValue | AnyDataValue | ObjectDataValue | GptFunctionDataValue | VectorDataValue | ImageDataValue | BinaryDataValue | AudioDataValue | GraphReferenceValue;
+export type ScalarType = ScalarDataValue['type'];
+export type ArrayDataValue<T extends ScalarDataValue> = DataValueDef<`${T['type']}[]`, T['value'][]>;
+export type FunctionDataValue<T extends ScalarOrArrayDataValue> = DataValueDef<`fn<${T['type']}>`, () => T['value']>;
+export type StringArrayDataValue = ArrayDataValue<StringDataValue>;
+export type ArrayDataValues = {
+    [P in ScalarDataValue['type']]: ArrayDataValue<Extract<ScalarDataValue, {
+        type: P;
+    }>>;
+}[ScalarDataValue['type']];
+export type ScalarOrArrayDataValue = ScalarDataValue | ArrayDataValues;
+export type FunctionDataValues = {
+    [P in ScalarOrArrayDataValue['type']]: FunctionDataValue<Extract<ScalarOrArrayDataValue, {
+        type: P;
+    }>>;
+}[ScalarOrArrayDataValue['type']];
+export type DataValue = ScalarDataValue | ArrayDataValues | FunctionDataValues;
+export type DataType = DataValue['type'];
+export type ScalarDataType = ScalarDataValue['type'];
+export type ArrayDataType = ArrayDataValues['type'];
+export type FunctionDataType = FunctionDataValues['type'];
+export type ScalarOrArrayDataType = ScalarOrArrayDataValue['type'];
+export type GetDataValue<Type extends DataType> = Extract<DataValue, {
+    type: Type;
+}>;
+/** A reference to large data stored outside the graphs themselves. */
+export type DataRef = {
+    refId: DataId;
+};
+export declare const dataTypes: ["any", "any[]", "boolean", "boolean[]", "string", "string[]", "number", "number[]", "date", "date[]", "time", "time[]", "datetime", "datetime[]", "chat-message", "chat-message[]", "control-flow-excluded", "control-flow-excluded[]", "object", "object[]", "fn<string>", "fn<number>", "fn<boolean>", "fn<date>", "fn<time>", "fn<datetime>", "fn<any>", "fn<object>", "fn<chat-message>", "fn<control-flow-excluded>", "fn<string[]>", "fn<number[]>", "fn<boolean[]>", "fn<date[]>", "fn<time[]>", "fn<datetime[]>", "fn<any[]>", "fn<object[]>", "fn<chat-message[]>", "fn<control-flow-excluded[]>", "gpt-function", "gpt-function[]", "fn<gpt-function[]>", "fn<gpt-function>", "vector", "vector[]", "fn<vector>", "fn<vector[]>", "image", "image[]", "fn<image>", "fn<image[]>", "binary", "binary[]", "fn<binary>", "fn<binary[]>", "audio", "audio[]", "fn<audio>", "fn<audio[]>", "graph-reference", "graph-reference[]", "fn<graph-reference>", "fn<graph-reference[]>"];
+export declare const scalarTypes: ["any", "boolean", "string", "number", "date", "time", "datetime", "chat-message", "control-flow-excluded", "object", "gpt-function", "vector", "image", "binary", "audio", "graph-reference"];
+export declare const dataTypeDisplayNames: Record<DataType, string>;
+export declare function isScalarDataValue(value: DataValue | undefined): value is ScalarDataValue;
+export declare function isScalarDataType(type: DataType): type is ScalarDataType;
+export declare function isArrayDataValue(value: DataValue | undefined): value is ArrayDataValues;
+export declare function isArrayDataType(type: DataType): type is ArrayDataType;
+export declare function isFunctionDataType(type: DataType): type is FunctionDataType;
+export declare function isFunctionDataValue(value: DataValue | undefined): value is FunctionDataValues;
+export declare function isNotFunctionDataValue(value: DataValue | undefined): value is ScalarOrArrayDataValue;
+export declare function functionTypeToScalarType(functionType: FunctionDataType): ScalarDataType;
+export declare function arrayTypeToScalarType(arrayType: ArrayDataType): ScalarDataType;
+export declare function getScalarTypeOf(type: DataType): ScalarDataType;
+/** Unwraps a potentially function data value to a concrete value. I.e., evaluates on-demand values. */
+export declare function unwrapDataValue(value: DataValue): ScalarOrArrayDataValue;
+/**
+ * Turns a { type: 'string[]', value: string[] } into { type: 'string', value: string }[]
+ * or a { type: 'object', value: something[] } into { type: 'object', value: something }[]
+ * or a { type: 'any', value: something[] } into { type: 'any', value: something }[]
+ * or a { type: 'string', value: string } into [{ type: 'string', value: string }]
+ */
+export declare const arrayizeDataValue: (value: ScalarOrArrayDataValue) => ScalarDataValue[];
+export declare const scalarDefaults: {
+    [P in ScalarDataType]: Extract<ScalarDataValue, {
+        type: P;
+    }>['value'];
+};
+export declare function getDefaultValue<T extends DataType>(type: T): (DataValue & {
+    type: T;
+})['value'];

package/dist/types/model/Dataset.d.ts

@@ -0,0 +1,19 @@
+import type { Opaque } from 'type-fest';
+import type { ProjectId } from '../index.js';
+export type DatasetId = Opaque<string, 'DatasetId'>;
+export type DatasetMetadata = {
+    id: DatasetId;
+    projectId: ProjectId;
+    name: string;
+    description: string;
+};
+export type Dataset = {
+    id: DatasetId;
+    rows: DatasetRow[];
+};
+export type DatasetRow = {
+    id: string;
+    data: string[];
+    /** An optional embedding for the row's data. */
+    embedding?: number[];
+};

package/dist/types/model/EditorDefinition.d.ts

@@ -0,0 +1,142 @@
+import { type ChartNode, type DataRef, type DataType, type DataValue, type DatasetId } from '../index.js';
+type ExcludeNeverValues<T> = Pick<T, {
+    [K in keyof T]: T[K] extends never ? never : K;
+}[keyof T]>;
+type DataOfType<T extends ChartNode, Type> = keyof ExcludeNeverValues<{
+    [P in keyof T['data']]-?: NonNullable<T['data'][P]> extends Type ? T['data'][P] : never;
+}>;
+export type SharedEditorDefinitionProps<T extends ChartNode> = {
+    label: string;
+    helperMessage?: string | ((data: T['data']) => string | undefined);
+    autoFocus?: boolean;
+    hideIf?: (data: T['data']) => boolean;
+    disableIf?: (data: T['data']) => boolean;
+};
+export type StringEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'string';
+    dataKey: DataOfType<T, string>;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+    placeholder?: string;
+    maxLength?: number;
+};
+export type ToggleEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'toggle';
+    dataKey: DataOfType<T, boolean>;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+};
+export type DataTypeSelectorEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'dataTypeSelector';
+    dataKey: DataOfType<T, DataType>;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+};
+export type DatasetSelectorEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'datasetSelector';
+    dataKey: DataOfType<T, DatasetId>;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+};
+export type AnyDataEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'anyData';
+    dataKey: DataOfType<T, any>;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+};
+export type DropdownEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'dropdown';
+    dataKey: DataOfType<T, string>;
+    options: {
+        value: string;
+        label: string;
+    }[];
+    defaultValue?: string;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+};
+export type GraphSelectorEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'graphSelector';
+    dataKey: DataOfType<T, string>;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+};
+export type NumberEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'number';
+    defaultValue?: number;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+    min?: number;
+    max?: number;
+    step?: number;
+} & ({
+    dataKey: DataOfType<T, number>;
+    allowEmpty?: false;
+} | {
+    dataKey: DataOfType<T, number | undefined>;
+    allowEmpty: true;
+});
+export type CodeEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'code';
+    dataKey: DataOfType<T, string>;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+    language: string;
+    theme?: string;
+    height?: number;
+};
+export type ColorEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'color';
+    dataKey: DataOfType<T, string>;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+};
+export type FilePathBrowserEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'filePathBrowser';
+    dataKey: DataOfType<T, string>;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+    accept?: string;
+};
+export type FileBrowserEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'fileBrowser';
+    dataKey: DataOfType<T, DataRef>;
+    mediaTypeDataKey: DataOfType<T, string>;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+    accept?: string;
+};
+export type ImageBrowserEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'imageBrowser';
+    dataKey: DataOfType<T, DataRef>;
+    mediaTypeDataKey: DataOfType<T, string>;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+};
+export type KeyValuePairEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'keyValuePair';
+    dataKey: DataOfType<T, {
+        key: string;
+        value: string;
+    }[]>;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+    keyPlaceholder?: string;
+    valuePlaceholder?: string;
+    valuesSecret?: boolean;
+};
+export type StringListEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'stringList';
+    dataKey: DataOfType<T, string[] | string>;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+    placeholder?: string;
+};
+export type EditorDefinitionGroup<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'group';
+    defaultOpen?: boolean;
+    editors: EditorDefinition<T>[];
+};
+export type CustomEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'custom';
+    customEditorId: string;
+    dataKey?: DataOfType<T, any>;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+    data?: any;
+};
+export type DynamicEditorEditor = EditorDefinition<any>['type'] | 'none' | 'auto';
+export type DynamicEditorDefinition<T extends ChartNode> = SharedEditorDefinitionProps<T> & {
+    type: 'dynamic';
+    dataKey: DataOfType<T, Record<string, DataValue>>;
+    dynamicDataKey: string;
+    useInputToggleDataKey?: DataOfType<T, boolean>;
+    dataType: DataType;
+    editor: DynamicEditorEditor;
+};
+export type EditorDefinition<T extends ChartNode> = StringEditorDefinition<T> | ToggleEditorDefinition<T> | DataTypeSelectorEditorDefinition<T> | AnyDataEditorDefinition<T> | DropdownEditorDefinition<T> | NumberEditorDefinition<T> | CodeEditorDefinition<T> | GraphSelectorEditorDefinition<T> | ColorEditorDefinition<T> | GraphSelectorEditorDefinition<T> | FileBrowserEditorDefinition<T> | ImageBrowserEditorDefinition<T> | DatasetSelectorEditorDefinition<T> | KeyValuePairEditorDefinition<T> | EditorDefinitionGroup<T> | StringListEditorDefinition<T> | CustomEditorDefinition<T> | DynamicEditorDefinition<T> | FilePathBrowserEditorDefinition<T>;
+export {};

package/dist/types/model/GraphProcessor.d.ts

@@ -0,0 +1,192 @@
+import { type DataValue, type StringArrayDataValue, type ScalarOrArrayDataValue } from './DataValue.js';
+import type { ChartNode, NodeConnection, NodeId, PortId } from './NodeBase.js';
+import type { GraphId, NodeGraph } from './NodeGraph.js';
+import type { UserInputNode } from './nodes/UserInputNode.js';
+import Emittery from 'emittery';
+import type { Project } from './Project.js';
+import type { InternalProcessContext, ProcessContext, ProcessId } from './ProcessContext.js';
+import type { ExecutionRecorder } from '../recording/ExecutionRecorder.js';
+import type { Opaque } from 'type-fest';
+import type { NodeRegistration } from './NodeRegistration.js';
+export type ProcessEvents = {
+    /** Called when processing has started. */
+    start: {
+        project: Project;
+        startGraph: NodeGraph;
+        inputs: GraphInputs;
+        contextValues: Record<string, DataValue>;
+    };
+    /** Called when a graph or subgraph has started. */
+    graphStart: {
+        graph: NodeGraph;
+        inputs: GraphInputs;
+    };
+    /** Called when a graph or subgraph has errored. */
+    graphError: {
+        graph: NodeGraph;
+        error: Error | string;
+    };
+    /** Called when a graph or a subgraph has finished. */
+    graphFinish: {
+        graph: NodeGraph;
+        outputs: GraphOutputs;
+    };
+    /** Called when a graph has been aborted. */
+    graphAbort: {
+        successful: boolean;
+        graph: NodeGraph;
+        error?: Error | string;
+    };
+    /** Called when a node has started processing, with the input values for the node. */
+    nodeStart: {
+        node: ChartNode;
+        inputs: Inputs;
+        processId: ProcessId;
+    };
+    /** Called when a node has finished processing, with the output values for the node. */
+    nodeFinish: {
+        node: ChartNode;
+        outputs: Outputs;
+        processId: ProcessId;
+    };
+    /** Called when a node has errored during processing. */
+    nodeError: {
+        node: ChartNode;
+        error: Error | string;
+        processId: ProcessId;
+    };
+    /** Called when a node has been excluded from processing. */
+    nodeExcluded: {
+        node: ChartNode;
+        processId: ProcessId;
+        inputs: Inputs;
+        outputs: Outputs;
+        reason: string;
+    };
+    /** Called when a user input node requires user input. Call the callback when finished, or call userInput() on the GraphProcessor with the results. */
+    userInput: {
+        node: UserInputNode;
+        inputs: Inputs;
+        callback: (values: StringArrayDataValue) => void;
+        processId: ProcessId;
+    };
+    /** Called when a node has partially processed, with the current partial output values for the node. */
+    partialOutput: {
+        node: ChartNode;
+        outputs: Outputs;
+        index: number;
+        processId: ProcessId;
+    };
+    /** Called when the outputs of a node have been cleared entirely. If processId is present, only the one process() should be cleared. */
+    nodeOutputsCleared: {
+        node: ChartNode;
+        processId?: ProcessId;
+    };
+    /** Called when the root graph has errored. The root graph will also throw. */
+    error: {
+        error: Error | string;
+    };
+    /** Called when processing has completed. */
+    done: {
+        results: GraphOutputs;
+    };
+    /** Called when processing has been aborted. */
+    abort: {
+        successful: boolean;
+        error?: string | Error;
+    };
+    /** Called when processing has finished either successfully or unsuccessfully. */
+    finish: void;
+    /** Called for trace level logs. */
+    trace: string;
+    /** Called when the graph has been paused. */
+    pause: void;
+    /** Called when the graph has been resumed. */
+    resume: void;
+    /** Called when a global variable has been set in a graph. */
+    globalSet: {
+        id: string;
+        value: ScalarOrArrayDataValue;
+        processId: ProcessId;
+    };
+    /** Called when an AbortController has been created. Used by node to increase the max event listeners. */
+    newAbortController: AbortController;
+} & {
+    /** Listen for any user event. */
+    [key: `userEvent:${string}`]: DataValue | undefined;
+} & {
+    [key: `globalSet:${string}`]: ScalarOrArrayDataValue | undefined;
+};
+export type ProcessEvent = {
+    [P in keyof ProcessEvents]: {
+        type: P;
+    } & ProcessEvents[P];
+}[keyof ProcessEvents];
+export type GraphOutputs = Record<string, DataValue>;
+export type GraphInputs = Record<string, DataValue>;
+export type NodeResults = Map<NodeId, Outputs>;
+export type Inputs = Record<PortId, DataValue | undefined>;
+export type Outputs = Record<PortId, DataValue | undefined>;
+export type ExternalFunctionProcessContext = Omit<InternalProcessContext, 'setGlobal'>;
+export type ExternalFunction = (context: ExternalFunctionProcessContext, ...args: unknown[]) => Promise<DataValue & {
+    cost?: number;
+}>;
+export type RaceId = Opaque<string, 'RaceId'>;
+export type LoopInfo = AttachedNodeDataItem & {
+    /** ID of the controller of the loop */
+    loopControllerId: NodeId;
+    /** Nodes add themselves to this as the loop processes */
+    nodes: Set<NodeId>;
+    iterationCount: number;
+};
+export type AttachedNodeDataItem = {
+    propagate: boolean | ((parent: ChartNode, connections: NodeConnection[]) => boolean);
+};
+export type AttachedNodeData = {
+    loopInfo?: LoopInfo;
+    races?: {
+        propagate: boolean;
+        raceIds: RaceId[];
+        completed: boolean;
+    };
+    [key: string]: AttachedNodeDataItem | undefined;
+};
+export declare class GraphProcessor {
+    #private;
+    slowMode: boolean;
+    id: string;
+    executor?: 'nodejs' | 'browser';
+    /** If set, specifies the node(s) that the graph will run TO, instead of the nodes without any dependents. */
+    runToNodeIds?: NodeId[];
+    /** The interval between nodeFinish events when playing back a recording. I.e. how fast the playback is. */
+    recordingPlaybackChatLatency: number;
+    warnOnInvalidGraph: boolean;
+    get isRunning(): boolean;
+    constructor(project: Project, graphId?: GraphId, registry?: NodeRegistration);
+    on: Emittery<ProcessEvents>["on"];
+    off: Emittery<ProcessEvents>["off"];
+    once: Emittery<ProcessEvents>["once"];
+    onAny: Emittery<ProcessEvents>["onAny"];
+    offAny: Emittery<ProcessEvents>["offAny"];
+    onUserEvent(onEvent: string, listener: (event: DataValue | undefined) => void): void;
+    offUserEvent(listener: (data: DataValue | undefined) => void): void;
+    userInput(nodeId: NodeId, values: StringArrayDataValue): void;
+    setExternalFunction(name: string, fn: ExternalFunction): void;
+    abort(successful?: boolean, error?: Error | string): Promise<void>;
+    pause(): void;
+    resume(): void;
+    setSlowMode(slowMode: boolean): void;
+    events(): AsyncGenerator<ProcessEvent>;
+    replayRecording(recorder: ExecutionRecorder): Promise<GraphOutputs>;
+    /** Main function for running a graph. Runs a graph and returns the outputs from the output nodes of the graph. */
+    processGraph(
+    /** Required and optional context available to the nodes and all subgraphs. */
+    context: ProcessContext, 
+    /** Inputs to the main graph. You should pass all inputs required by the GraphInputNodes of the graph. */
+    inputs?: Record<string, DataValue>, 
+    /** Contextual data available to all graphs and subgraphs. Kind of like react context, avoids drilling down data into subgraphs. Be careful when using it. */
+    contextValues?: Record<string, DataValue>): Promise<GraphOutputs>;
+    getRootProcessor(): GraphProcessor;
+    /** Raise a user event on the processor, all subprocessors, and their children. */
+    raiseEvent(event: string, data: DataValue): void;
+}

package/dist/types/model/NodeBase.d.ts

@@ -0,0 +1,110 @@
+import type { Opaque } from 'type-fest';
+import type { DataType } from './DataValue.js';
+import type { GraphId } from '../index.js';
+/** Unique in a NodeGraph. */
+export type NodeId = Opaque<string, 'NodeId'>;
+/** Unique within the inputs of a single node */
+export type PortId = Opaque<string, 'PortId'>;
+/** Base interface for a node in a NodeGraph. All nodes will have this data.*/
+export interface NodeBase {
+    /** The type of the node. See Nodes['type']. */
+    type: string;
+    /** The unique identifier of the node. Unique within a NodeGraph. */
+    id: NodeId;
+    /** The title of the node. Displayed in the graph. */
+    title: string;
+    /** A user description/notes for the node */
+    description?: string;
+    isSplitRun?: boolean;
+    /** When splitting, should the executions be ran sequentially instead of in parallel? */
+    isSplitSequential?: boolean;
+    splitRunMax?: number;
+    /** The visual data of the node, including its position. Visual data does not affect its processing. */
+    visualData: {
+        /** The x-coordinate of the node's position. */
+        x: number;
+        /** The y-coordinate of the node's position. */
+        y: number;
+        width?: number;
+        /** The accent color of the node in the UI. */
+        color?: {
+            border: string;
+            bg: string;
+        };
+        /** The z-index, the last grabbed node is on top of all others. */
+        zIndex?: number;
+    };
+    /** The data associated with the node. Typed when using `Nodes` or a subtype. */
+    data: unknown;
+    /** Alternative sets of data for the node. */
+    variants?: ChartNodeVariant<unknown>[];
+    tests?: NodeTestGroup[];
+    /** If true, the node is disabled and effectively "not ran" */
+    disabled?: boolean;
+}
+/** Base type for a typed node. */
+export type ChartNode<Type extends string = string, Data = unknown> = NodeBase & {
+    /** The type of the node. */
+    type: Type;
+    /** The data associated with the node. */
+    data: Data;
+    /** Alternative sets of data for the node. */
+    variants?: ChartNodeVariant<Data>[];
+};
+export type ChartNodeVariant<Data = unknown> = {
+    id: string;
+    data: Data;
+};
+export type NodeTestGroup = {
+    id: string;
+    evaluatorGraphId: GraphId;
+    tests: NodeTest[];
+};
+export type NodeTest = {
+    conditionText: string;
+};
+/** Represents an input definition of a node. */
+export type NodeInputDefinition = {
+    /** The unique identifier of the input. Unique within a single node only. */
+    id: PortId;
+    /** The title of the input. Shows in the UI. */
+    title: string;
+    /** Whether the input is required. If it is required, there is no default value, and the node cannot process if this input is not connected. */
+    required?: boolean;
+    /** The data type of the input. */
+    dataType: DataType | Readonly<DataType[]>;
+    /** Other data associated with the input. Typed in subtypes. */
+    data?: unknown;
+    /** The default value of the input, if it is not connected to an output. */
+    defaultValue?: unknown;
+    /** User-facing description of the port. */
+    description?: string;
+    /** Will the input value attempt to be coerced into the desired type? */
+    coerced?: boolean;
+};
+/** Represents an output definition of a node. */
+export type NodeOutputDefinition = {
+    /** The unique identifier of the output. Unique within a single node. */
+    id: PortId;
+    /** The title of the output. Shown in the UI. */
+    title: string;
+    /** The data type of the output. */
+    dataType: DataType | Readonly<DataType[]>;
+    /** The data associated with the output. */
+    data?: unknown;
+    /** The default value of the output. Some outputs just have a fixed value. */
+    defaultValue?: unknown;
+    /** User-facing description of the port. */
+    description?: string;
+};
+/** Represents a connection between two nodes. */
+export type NodeConnection = {
+    /** The unique identifier of the output node. */
+    outputNodeId: NodeId;
+    /** The unique identifier of the input node. */
+    inputNodeId: NodeId;
+    /** The unique identifier of the output. */
+    outputId: PortId;
+    /** The unique identifier of the input. */
+    inputId: PortId;
+};

package/dist/types/model/NodeBodySpec.d.ts

@@ -0,0 +1,19 @@
+export type NodeBodySpecBase = {
+    fontSize?: number;
+    fontFamily?: 'monospace' | 'sans-serif';
+};
+export type PlainNodeBodySpec = {
+    type: 'plain';
+    text: string;
+};
+export type MarkdownNodeBodySpec = {
+    type: 'markdown';
+    text: string;
+};
+export type ColorizedNodeBodySpec = {
+    type: 'colorized';
+    language: string;
+    text: string;
+    theme?: string;
+};
+export type NodeBodySpec = NodeBodySpecBase & (PlainNodeBodySpec | MarkdownNodeBodySpec | ColorizedNodeBodySpec);

package/dist/types/model/NodeDefinition.d.ts

@@ -0,0 +1,13 @@
+import type { ChartNode } from './NodeBase.js';
+import type { NodeImplConstructor, PluginNodeImpl } from './NodeImpl.js';
+export type NodeDefinition<T extends ChartNode> = {
+    impl: NodeImplConstructor<T>;
+    displayName: string;
+};
+export type PluginNodeDefinition<T extends ChartNode> = {
+    impl: PluginNodeImpl<T>;
+    displayName: string;
+};
+export type UnknownNodeDefinition = NodeDefinition<ChartNode>;
+export declare function nodeDefinition<T extends ChartNode>(impl: NodeImplConstructor<T>, displayName: string): NodeDefinition<T>;
+export declare function pluginNodeDefinition<T extends ChartNode>(impl: PluginNodeImpl<T>, displayName: string): PluginNodeDefinition<T>;

package/dist/types/model/NodeGraph.d.ts

@@ -0,0 +1,15 @@
+import { type ChartNode, type NodeConnection } from './NodeBase.js';
+import type { Opaque } from 'type-fest';
+import { type AttachedData } from '../utils/serialization/serializationUtils.js';
+export type GraphId = Opaque<string, 'GraphId'>;
+export interface NodeGraph {
+    metadata?: {
+        id?: GraphId;
+        name?: string;
+        description?: string;
+        attachedData?: AttachedData;
+    };
+    nodes: ChartNode[];
+    connections: NodeConnection[];
+}
+export declare function emptyNodeGraph(): NodeGraph;