@alpic80/rivet-core 1.19.1-aidon.3 → 1.24.0-aidon.3

package/dist/types/model/nodes/ChatNodeBase.d.ts

@@ -0,0 +1,85 @@
+import { type ChatMessage } from '../DataValue.js';
+import type { EditorDefinition } from '../EditorDefinition.js';
+import type { ChartNode, NodeInputDefinition } from '../NodeBase.js';
+import type { ChatNode } from './ChatNode.js';
+import type { Inputs, Outputs } from '../GraphProcessor.js';
+import type { InternalProcessContext } from '../ProcessContext.js';
+export type ChatNodeConfigData = {
+    model: string;
+    temperature: number;
+    useTopP: boolean;
+    top_p?: number;
+    maxTokens: number;
+    stop?: string;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    enableFunctionUse?: boolean;
+    user?: string;
+    numberOfChoices?: number;
+    endpoint?: string;
+    overrideModel?: string;
+    overrideMaxTokens?: number;
+    headers?: {
+        key: string;
+        value: string;
+    }[];
+    seed?: number;
+    toolChoice?: 'none' | 'auto' | 'function';
+    toolChoiceFunction?: string;
+    responseFormat?: '' | 'text' | 'json' | 'json_schema';
+    parallelFunctionCalling?: boolean;
+    additionalParameters?: {
+        key: string;
+        value: string;
+    }[];
+    responseSchemaName?: string;
+    useServerTokenCalculation?: boolean;
+    outputUsage?: boolean;
+    usePredictedOutput?: boolean;
+    reasoningEffort?: '' | 'low' | 'medium' | 'high';
+    modalitiesIncludeText?: boolean;
+    modalitiesIncludeAudio?: boolean;
+    audioVoice?: string;
+    audioFormat?: 'wav' | 'mp3' | 'flac' | 'opus' | 'pcm16';
+};
+export type ChatNodeData = ChatNodeConfigData & {
+    useModelInput: boolean;
+    useTemperatureInput: boolean;
+    useTopPInput: boolean;
+    useTopP: boolean;
+    useUseTopPInput: boolean;
+    useMaxTokensInput: boolean;
+    useStop: boolean;
+    useStopInput: boolean;
+    usePresencePenaltyInput: boolean;
+    useFrequencyPenaltyInput: boolean;
+    useUserInput?: boolean;
+    useNumberOfChoicesInput?: boolean;
+    useEndpointInput?: boolean;
+    useHeadersInput?: boolean;
+    useSeedInput?: boolean;
+    useToolChoiceInput?: boolean;
+    useToolChoiceFunctionInput?: boolean;
+    useResponseFormatInput?: boolean;
+    useAdditionalParametersInput?: boolean;
+    useResponseSchemaNameInput?: boolean;
+    useAudioVoiceInput?: boolean;
+    useAudioFormatInput?: boolean;
+    useReasoningEffortInput?: boolean;
+    /** Given the same set of inputs, return the same output without hitting GPT */
+    cache: boolean;
+    useAsGraphPartialOutput?: boolean;
+};
+export declare const ChatNodeBase: {
+    defaultData: () => ChatNodeData;
+    getInputDefinitions: (data: ChatNodeData) => NodeInputDefinition[];
+    getOutputDefinitions: (data: ChatNodeData) => NodeInputDefinition[];
+    getEditors: () => EditorDefinition<ChatNode>[];
+    getBody: (data: ChatNodeData) => string | undefined;
+    process: (data: ChatNodeData, node: ChartNode, inputs: Inputs, context: InternalProcessContext) => Promise<Outputs>;
+};
+export declare function getChatNodeMessages(inputs: Inputs): {
+    messages: ChatMessage[];
+    systemPrompt: import("../DataValue.js").DataValue | undefined;
+};
+export declare function getCostForTokens(tokenCount: number, costPerThousand: number): number;

package/dist/types/model/nodes/CodeNode.d.ts

@@ -1,13 +1,19 @@
 import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
 import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
-import { type DataValue } from '../DataValue.js';
 import { type EditorDefinition } from '../EditorDefinition.js';
 import { type NodeBodySpec } from '../NodeBodySpec.js';
+import type { InternalProcessContext } from '../ProcessContext.js';
+import type { Inputs, Outputs } from '../GraphProcessor.js';
 export type CodeNode = ChartNode<'code', CodeNodeData>;
 export type CodeNodeData = {
     code: string;
     inputNames: string | string[];
     outputNames: string | string[];
+    allowFetch?: boolean;
+    allowRequire?: boolean;
+    allowRivet?: boolean;
+    allowProcess?: boolean;
+    allowConsole?: boolean;
 };
 export declare class CodeNodeImpl extends NodeImpl<CodeNode> {
     static create(): CodeNode;
@@ -16,6 +22,6 @@ export declare class CodeNodeImpl extends NodeImpl<CodeNode> {
     getEditors(): EditorDefinition<CodeNode>[];
     getBody(): string | NodeBodySpec | undefined;
     static getUIData(): NodeUIData;
-    process(inputs: Record<string, DataValue>): Promise<Record<string, DataValue>>;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
 }
 export declare const codeNode: import("../NodeDefinition.js").NodeDefinition<CodeNode>;

package/dist/types/model/nodes/CronNode.d.ts

@@ -0,0 +1,34 @@
+import type { ChartNode, NodeInputDefinition, NodeOutputDefinition } from '../NodeBase.js';
+import type { GraphId } from '../NodeGraph.js';
+import { NodeImpl, type NodeBody } from '../NodeImpl.js';
+import type { EditorDefinition } from '../EditorDefinition.js';
+import type { RivetUIContext } from '../RivetUIContext.js';
+import type { InternalProcessContext } from '../ProcessContext.js';
+import type { Inputs, Outputs } from '../GraphProcessor.js';
+type ScheduleType = 'interval' | 'cron';
+export type CronNode = ChartNode<'cron', CronNodeData>;
+export type CronNodeData = {
+    targetGraph: GraphId | undefined;
+    scheduleType: ScheduleType;
+    schedule: string;
+    executeImmediately?: boolean;
+    useTargetGraphInput?: boolean;
+};
+export declare class CronNodeImpl extends NodeImpl<CronNode> {
+    static create(): CronNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): {
+        infoBoxBody: string;
+        infoBoxTitle: string;
+        contextMenuTitle: string;
+        group: string[];
+    };
+    getEditors(): EditorDefinition<CronNode>[];
+    private parseSchedule;
+    private getNextRunTime;
+    getBody(context: RivetUIContext): NodeBody;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const cronNode: import("../NodeDefinition.js").NodeDefinition<CronNode>;
+export {};

package/dist/types/model/nodes/DelegateFunctionCallNode.d.ts

@@ -12,6 +12,7 @@ export type DelegateFunctionCallNodeData = {
         value: GraphId;
     }[];
     unknownHandler: GraphId | undefined;
+    autoDelegate: boolean;
 };
 export declare class DelegateFunctionCallNodeImpl extends NodeImpl<DelegateFunctionCallNode> {
     static create(): DelegateFunctionCallNode;

package/dist/types/model/nodes/DocumentNode.d.ts

@@ -0,0 +1,28 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type DataRef, type EditorDefinition, type Inputs, type InternalProcessContext, type NodeBody, type Outputs, type SupportedDocumentMediaTypes } from '../../index.js';
+import type { RivetUIContext } from '../RivetUIContext.js';
+export type DocumentNode = ChartNode<'document', DocumentNodeData>;
+type DocumentNodeData = {
+    data?: DataRef;
+    useDataInput: boolean;
+    mediaType?: SupportedDocumentMediaTypes;
+    useMediaTypeInput: boolean;
+    title: string;
+    useTitleInput: boolean;
+    context: string;
+    useContextInput: boolean;
+    enableCitations: boolean;
+    useEnableCitationsInput: boolean;
+};
+export declare class DocumentNodeImpl extends NodeImpl<DocumentNode> {
+    static create(): DocumentNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<DocumentNode>[];
+    static getUIData(): NodeUIData;
+    getBody(_context: RivetUIContext): NodeBody | Promise<NodeBody>;
+    process(inputData: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const documentNode: import("../NodeDefinition.js").NodeDefinition<DocumentNode>;
+export {};

package/dist/types/model/nodes/GetAllDatasetsNode.d.ts

@@ -1,4 +1,4 @@
-import type { ChartNode, EditorDefinition, Inputs, InternalProcessContext, NodeInputDefinition, NodeOutputDefinition, NodeUIData, Outputs } from '../../index.js';
+import type { ChartNode, EditorDefinition, InternalProcessContext, NodeInputDefinition, NodeOutputDefinition, NodeUIData, Outputs } from '../../index.js';
 import { NodeImpl } from '../NodeImpl.js';
 export type GetAllDatasetsNode = ChartNode<'getAllDatasets', GetAllDatasetsNodeData>;
 type GetAllDatasetsNodeData = {};
@@ -8,7 +8,7 @@ export declare class GetAllDatasetsNodeImpl extends NodeImpl<GetAllDatasetsNode>
     getOutputDefinitions(): NodeOutputDefinition[];
     static getUIData(): NodeUIData;
     getEditors(): EditorDefinition<GetAllDatasetsNode>[] | Promise<EditorDefinition<GetAllDatasetsNode>[]>;
-    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+    process(context: InternalProcessContext): Promise<Outputs>;
 }
 export declare const getAllDatasetsNode: import("../NodeDefinition.js").NodeDefinition<GetAllDatasetsNode>;
 export {};

package/dist/types/model/nodes/LoopUntilNode.d.ts

@@ -0,0 +1,32 @@
+import { type ChartNode, type NodeConnection, type NodeId, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type GraphId } from '../NodeGraph.js';
+import { type Project } from '../Project.js';
+import { type DataValue } from '../DataValue.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import { type EditorDefinition } from '../EditorDefinition.js';
+import type { RivetUIContext } from '../RivetUIContext.js';
+type ConditionType = 'allOutputsSet' | 'inputEqual';
+export type LoopUntilNode = ChartNode<'loopUntil', LoopUntilNodeData>;
+export type LoopUntilNodeData = {
+    targetGraph: GraphId | undefined;
+    conditionType: ConditionType;
+    maxIterations?: number;
+    inputToCheck?: string;
+    targetValue?: string;
+    /** Data for each of the inputs of the subgraph */
+    inputData?: Record<string, DataValue>;
+};
+export declare class LoopUntilNodeImpl extends NodeImpl<LoopUntilNode> {
+    static create(): LoopUntilNode;
+    getInputDefinitions(_connections: NodeConnection[], _nodes: Record<NodeId, ChartNode>, project: Project): NodeInputDefinition[];
+    getOutputDefinitions(_connections: NodeConnection[], _nodes: Record<NodeId, ChartNode>, project: Project): NodeOutputDefinition[];
+    getEditors(context: RivetUIContext): EditorDefinition<LoopUntilNode>[];
+    static getUIData(): NodeUIData;
+    getBody(context: RivetUIContext): string;
+    private shouldBreak;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const loopUntilNode: import("../NodeDefinition.js").NodeDefinition<LoopUntilNode>;
+export {};

package/dist/types/model/nodes/ObjectNode.d.ts

@@ -1,4 +1,4 @@
-import { type ChartNode, type NodeConnection, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
 import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
 import { type DataValue } from '../DataValue.js';
 import { type EditorDefinition } from '../EditorDefinition.js';
@@ -8,7 +8,7 @@ export type ObjectNodeData = {
 };
 export declare class ObjectNodeImpl extends NodeImpl<ObjectNode> {
     static create(): ObjectNode;
-    getInputDefinitions(connections: NodeConnection[]): NodeInputDefinition[];
+    getInputDefinitions(): NodeInputDefinition[];
     getOutputDefinitions(): NodeOutputDefinition[];
     getEditors(): EditorDefinition<ObjectNode>[];
     static getUIData(): NodeUIData;

package/dist/types/model/nodes/PromptNode.d.ts

@@ -10,6 +10,8 @@ export type PromptNodeData = {
     useNameInput?: boolean;
     enableFunctionCall?: boolean;
     computeTokenCount?: boolean;
+    isCacheBreakpoint?: boolean;
+    useIsCacheBreakpointInput?: boolean;
 };
 export declare class PromptNodeImpl extends NodeImpl<PromptNode> {
     static create(): PromptNode;

package/dist/types/model/nodes/RaceInputsNode.d.ts

@@ -1,7 +1,6 @@
 import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition, type NodeConnection } from '../NodeBase.js';
 import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
 import { type Inputs, type Outputs } from '../GraphProcessor.js';
-import { type InternalProcessContext } from '../ProcessContext.js';
 import { type EditorDefinition } from '../../index.js';
 export type RaceInputsNode = ChartNode<'raceInputs', RaceInputsNodeData>;
 export type RaceInputsNodeData = {};
@@ -12,6 +11,6 @@ export declare class RaceInputsNodeImpl extends NodeImpl<RaceInputsNode> {
     getOutputDefinitions(): NodeOutputDefinition[];
     getEditors(): EditorDefinition<RaceInputsNode>[];
     static getUIData(): NodeUIData;
-    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+    process(inputs: Inputs): Promise<Outputs>;
 }
 export declare const raceInputsNode: import("../NodeDefinition.js").NodeDefinition<RaceInputsNode>;

package/dist/types/model/nodes/ReadAllFilesNode.d.ts

@@ -0,0 +1,30 @@
+import { type ChartNode, type PortId, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { type DataValue } from '../DataValue.js';
+import { NodeImpl, type NodeBody, type NodeUIData } from '../NodeImpl.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import type { EditorDefinition } from '../EditorDefinition.js';
+import type { Inputs } from '../GraphProcessor.js';
+export type ReadAllFilesNode = ChartNode<'readAllFiles', ReadAllFilesNodeData>;
+type ReadAllFilesNodeData = {
+    path: string;
+    usePathInput: boolean;
+    recursive: boolean;
+    useRecursiveInput: boolean;
+    filterGlobs: string[];
+    useFilterGlobsInput: boolean;
+    ignores?: string[];
+    useIgnoresInput: boolean;
+    asBinary?: boolean;
+    errorOnMissingFile?: boolean;
+};
+export declare class ReadAllFilesNodeImpl extends NodeImpl<ReadAllFilesNode> {
+    static create(): ReadAllFilesNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<ReadAllFilesNode>[];
+    getBody(): NodeBody;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Record<PortId, DataValue>>;
+}
+export declare const readAllFilesNode: import("../NodeDefinition.js").NodeDefinition<ReadAllFilesNode>;
+export {};

package/dist/types/model/nodes/ReadDirectoryNode.d.ts

@@ -24,7 +24,7 @@ export declare class ReadDirectoryNodeImpl extends NodeImpl<ReadDirectoryNode> {
     getOutputDefinitions(): NodeOutputDefinition[];
     getBody(): string | NodeBodySpec | undefined;
     static getUIData(): NodeUIData;
-    process(inputData: Inputs, context: InternalProcessContext): Promise<Outputs>;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
 }
 export declare const readDirectoryNode: import("../NodeDefinition.js").NodeDefinition<ReadDirectoryNode>;
 export {};

package/dist/types/model/nodes/ReferencedGraphAliasNode.d.ts

@@ -0,0 +1,31 @@
+import { type ChartNode, type NodeConnection, type NodeId, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeBody, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type GraphId } from '../NodeGraph.js';
+import { type Project, type ProjectId } from '../Project.js';
+import { type DataValue } from '../DataValue.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import type { RivetUIContext } from '../RivetUIContext.js';
+import type { EditorDefinition } from '../EditorDefinition.js';
+export type ReferencedGraphAliasNode = ChartNode & {
+    type: 'referencedGraphAlias';
+    data: {
+        projectId: ProjectId;
+        graphId: GraphId;
+        useErrorOutput?: boolean;
+        outputCostDuration?: boolean;
+        /** Data for each of the inputs of the referenced graph */
+        inputData?: Record<string, DataValue>;
+    };
+};
+export declare class ReferencedGraphAliasNodeImpl extends NodeImpl<ReferencedGraphAliasNode> {
+    static create(): ReferencedGraphAliasNode;
+    getInputDefinitions(_connections: NodeConnection[], _nodes: Record<NodeId, ChartNode>, _project: Project, referencedProjects: Record<ProjectId, Project>): NodeInputDefinition[];
+    getGraphOutputs(referencedProject: Project): NodeOutputDefinition[];
+    getOutputDefinitions(_connections: NodeConnection[], _nodes: Record<NodeId, ChartNode>, _project: Project, referencedProjects: Record<ProjectId, Project>): NodeOutputDefinition[];
+    getEditors(context: RivetUIContext): EditorDefinition<ReferencedGraphAliasNode>[];
+    getBody(context: RivetUIContext): NodeBody | Promise<NodeBody>;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+}
+export declare const referencedGraphAliasNode: import("../NodeDefinition.js").NodeDefinition<ReferencedGraphAliasNode>;

package/dist/types/model/nodes/SplitNode.d.ts

@@ -1,4 +1,4 @@
-import type { ChartNode, NodeInputDefinition, NodeOutputDefinition, NodeUIData, EditorDefinition, Inputs, InternalProcessContext, Outputs, NodeBodySpec } from '../../index.js';
+import type { ChartNode, NodeInputDefinition, NodeOutputDefinition, NodeUIData, EditorDefinition, Inputs, Outputs, NodeBodySpec } from '../../index.js';
 import { NodeImpl } from '../NodeImpl.js';
 export type SplitNode = ChartNode<'split', SplitNodeData>;
 type SplitNodeData = {
@@ -13,7 +13,7 @@ export declare class SplitNodeImpl extends NodeImpl<SplitNode> {
     static getUIData(): NodeUIData;
     getEditors(): EditorDefinition<SplitNode>[] | Promise<EditorDefinition<SplitNode>[]>;
     getBody(): string | NodeBodySpec | NodeBodySpec[] | undefined;
-    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
+    process(inputs: Inputs): Promise<Outputs>;
 }
 export declare const splitNode: import("../NodeDefinition.js").NodeDefinition<SplitNode>;
 export {};

package/dist/types/model/nodes/ToMarkdownTableNode.d.ts

@@ -0,0 +1,19 @@
+import { type ChartNode, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type Inputs, type Outputs } from '../GraphProcessor.js';
+import { type EditorDefinition } from '../../index.js';
+export type ToMarkdownTableNode = ChartNode<'toMarkdownTable', ToMarkdownTableNodeData>;
+export type ToMarkdownTableNodeData = {
+    includeHeaders?: boolean;
+    alignPipes?: boolean;
+};
+export declare class ToMarkdownTableNodeImpl extends NodeImpl<ToMarkdownTableNode> {
+    static create(): ToMarkdownTableNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<ToMarkdownTableNode>[];
+    getBody(): string | undefined;
+    static getUIData(): NodeUIData;
+    process(inputs: Inputs): Promise<Outputs>;
+}
+export declare const toMarkdownTableNode: import("../NodeDefinition.js").NodeDefinition<ToMarkdownTableNode>;

package/dist/types/model/nodes/ToTreeNode.d.ts

@@ -0,0 +1,21 @@
+import { type ChartNode, type NodeInputDefinition, type PortId, type NodeOutputDefinition } from '../NodeBase.js';
+import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
+import { type DataValue } from '../DataValue.js';
+import { type EditorDefinition } from '../EditorDefinition.js';
+export type ToTreeNode = ChartNode<'toTree', ToTreeNodeData>;
+export type ToTreeNodeData = {
+    format: string;
+    childrenProperty: string;
+    useSortAlphabetically: boolean;
+};
+export declare class ToTreeNodeImpl extends NodeImpl<ToTreeNode> {
+    static create(): ToTreeNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    getEditors(): EditorDefinition<ToTreeNode>[];
+    getBody(): string;
+    static getUIData(): NodeUIData;
+    buildTree(objects: unknown[], parentPath?: string, level?: number, isLast?: boolean): string;
+    process(inputs: Record<PortId, DataValue>): Promise<Record<PortId, DataValue>>;
+}
+export declare const toTreeNode: import("../NodeDefinition.js").NodeDefinition<ToTreeNode>;

package/dist/types/model/nodes/UserInputNode.d.ts

@@ -1,7 +1,7 @@
 import { NodeImpl, type NodeUIData } from '../NodeImpl.js';
 import type { ChartNode, NodeInputDefinition, NodeOutputDefinition } from '../NodeBase.js';
-import type { ArrayDataValue, StringDataValue } from '../DataValue.js';
 import { type Outputs, type Inputs, type EditorDefinition, type NodeBodySpec } from '../../index.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
 export type UserInputNode = ChartNode<'userInput', UserInputNodeData>;
 export type UserInputNodeData = {
     prompt: string;
@@ -15,7 +15,6 @@ export declare class UserInputNodeImpl extends NodeImpl<UserInputNode> {
     getEditors(): EditorDefinition<UserInputNode>[];
     getBody(): string | NodeBodySpec | undefined;
     static getUIData(): NodeUIData;
-    process(): Promise<Outputs>;
-    getOutputValuesFromUserInput(questions: Inputs, answers: ArrayDataValue<StringDataValue>): Outputs;
+    process(inputs: Inputs, context: InternalProcessContext): Promise<Outputs>;
 }
 export declare const userInputNode: import("../NodeDefinition.js").NodeDefinition<UserInputNode>;

package/dist/types/model/nodes/WriteFileNode.d.ts

@@ -0,0 +1,23 @@
+import { type ChartNode, type PortId, type NodeInputDefinition, type NodeOutputDefinition } from '../NodeBase.js';
+import { type DataValue } from '../DataValue.js';
+import { NodeImpl, type NodeBody, type NodeUIData } from '../NodeImpl.js';
+import { type InternalProcessContext } from '../ProcessContext.js';
+import type { EditorDefinition } from '../EditorDefinition.js';
+export type WriteFileNode = ChartNode<'writeFile', WriteFileNodeData>;
+type WriteFileNodeData = {
+    path: string;
+    usePathOutput: boolean;
+    asBinary?: boolean;
+    overwriteExistingFile?: boolean;
+};
+export declare class WriteFileNodeImpl extends NodeImpl<WriteFileNode> {
+    static create(): WriteFileNode;
+    getInputDefinitions(): NodeInputDefinition[];
+    getOutputDefinitions(): NodeOutputDefinition[];
+    static getUIData(): NodeUIData;
+    getEditors(): EditorDefinition<WriteFileNode>[];
+    getBody(): NodeBody;
+    process(inputData: Record<PortId, DataValue>, context: InternalProcessContext): Promise<Record<PortId, DataValue>>;
+}
+export declare const writeFileNode: import("../NodeDefinition.js").NodeDefinition<WriteFileNode>;
+export {};

package/dist/types/native/BrowserNativeApi.d.ts

@@ -1,11 +1,14 @@
 import { type BaseDir } from './BaseDir.js';
-import { type NativeApi } from './NativeApi.js';
+import { type NativeApi, type Status } from './NativeApi.js';
 export declare class BrowserNativeApi implements NativeApi {
+    createdir(_path: string, _recursive?: boolean, _baseDir?: BaseDir): Promise<Status>;
     readdir(_path: string, _baseDir: BaseDir): Promise<string[]>;
     readTextFile(_path: string, _baseDir: BaseDir): Promise<string>;
     readBinaryFile(_path: string, _baseDir: BaseDir): Promise<Blob>;
-    writeTextFile(_path: string, _data: string, _baseDir?: BaseDir): Promise<void>;
-    exec(command: string, args: string[], options?: {
-        cwd?: string | undefined;
-    } | undefined): Promise<void>;
+    writeTextFile(_path: string, _data: string, _baseDir?: BaseDir): Promise<Status>;
+    writeBinaryFile(_path: string, _data: Uint8Array, _baseDir?: BaseDir): Promise<Status>;
+    exists(_path: string, _baseDir?: BaseDir): Promise<boolean>;
+    join(..._paths: string[]): Promise<string>;
+    uniqueFilename(_path: string, _baseDir?: BaseDir): Promise<string>;
+    exec(): Promise<void>;
 }

package/dist/types/native/NativeApi.d.ts

@@ -6,11 +6,22 @@ export type ReadDirOptions = {
     relative?: boolean;
     ignores?: string[];
 };
+export type Status = {
+    success: true;
+} | {
+    success: false;
+    error: unknown;
+};
 export interface NativeApi {
+    createdir(path: string, recursive?: boolean, baseDir?: BaseDir): Promise<Status>;
     readdir(path: string, baseDir?: BaseDir, options?: ReadDirOptions): Promise<string[]>;
     readTextFile(path: string, baseDir?: BaseDir): Promise<string>;
     readBinaryFile(path: string, baseDir?: BaseDir): Promise<Blob>;
-    writeTextFile(path: string, data: string, baseDir?: BaseDir): Promise<void>;
+    writeTextFile(path: string, data: string, baseDir?: BaseDir): Promise<Status>;
+    writeBinaryFile(path: string, data: Uint8Array, baseDir?: BaseDir): Promise<Status>;
+    exists(path: string, baseDir?: BaseDir): Promise<boolean>;
+    join(...paths: string[]): Promise<string>;
+    uniqueFilename(path: string, baseDir?: BaseDir): Promise<string>;
     exec(command: string, args: string[], options?: {
         cwd?: string;
     }): Promise<void>;