agency-lang 0.0.57 → 0.0.59

package/README.md

@@ -25,7 +25,7 @@ agency infile.agency
 Note that the generated files use several other libraries that you will need to install as well:
 
 ```bash
-pnpm i nanoid openai piemachine statelog-client zod
+pnpm i nanoid openai zod smoltalk
 ```
 
 ## troubleshooting

package/dist/lib/backends/agencyGenerator.d.ts

@@ -5,9 +5,9 @@ import { TimeBlock } from "../types/timeBlock.js";
 import { AccessExpression, DotFunctionCall, DotProperty, IndexAccess } from "../types/access.js";
 import { AgencyArray, AgencyObject } from "../types/dataStructures.js";
 import { FunctionCall, FunctionDefinition } from "../types/function.js";
-import { GraphNodeDefinition } from "../types/graphNode.js";
+import { GraphNodeDefinition, Visibility } from "../types/graphNode.js";
 import { IfElse } from "../types/ifElse.js";
-import { ImportNodeStatement, ImportStatement, ImportToolStatement } from "../types/importStatement.js";
+import { ImportNameType, ImportNodeStatement, ImportStatement, ImportToolStatement } from "../types/importStatement.js";
 import { MatchBlock } from "../types/matchBlock.js";
 import { ReturnStatement } from "../types/returnStatement.js";
 import { UsesTool } from "../types/tools.js";
@@ -55,8 +55,10 @@ export declare class AgencyGenerator extends BaseGenerator {
     protected processReturnStatement(node: ReturnStatement): string;
     protected processComment(node: AgencyComment): string;
     protected processImportStatement(node: ImportStatement): string;
+    protected processImportNameType(node: ImportNameType): string;
     protected processImportNodeStatement(node: ImportNodeStatement): string;
     protected processImportToolStatement(node: ImportToolStatement): string;
+    protected visibilityToString(vis: Visibility): string;
     protected processGraphNode(node: GraphNodeDefinition): string;
     protected processTool(node: FunctionDefinition): string;
     protected processUsesTool(node: UsesTool): string;

package/dist/lib/backends/agencyGenerator.js

@@ -341,15 +341,36 @@ export class AgencyGenerator extends BaseGenerator {
         return this.indentStr(`//${node.content}`);
     }
     processImportStatement(node) {
-        const str = this.indentStr(`import ${node.importedNames}from "${node.modulePath}"`);
+        const importedNames = node.importedNames.map((name) => this.processImportNameType(name));
+        const str = this.indentStr(`import ${importedNames.join(", ")} from "${node.modulePath}"`);
         return str;
     }
+    processImportNameType(node) {
+        switch (node.type) {
+            case "namedImport":
+                return `{ ${node.importedNames.join(", ")} }`;
+            case "namespaceImport":
+                return `* as ${node.importedNames}`;
+            case "defaultImport":
+                return `${node.importedNames}`;
+        }
+    }
     processImportNodeStatement(node) {
         return `import node { ${node.importedNodes.join(", ")} } from "${node.agencyFile}"`;
     }
     processImportToolStatement(node) {
         return `import tool { ${node.importedTools.join(", ")} } from "${node.agencyFile}"`;
     }
+    visibilityToString(vis) {
+        switch (vis) {
+            case "public":
+                return "public ";
+            case "private":
+                return "private ";
+            case undefined:
+                return "";
+        }
+    }
     processGraphNode(node) {
         // Graph nodes use similar syntax to functions
         const { nodeName, body, parameters } = node;
@@ -361,7 +382,8 @@ export class AgencyGenerator extends BaseGenerator {
         const returnTypeStr = node.returnType
             ? ": " + variableTypeToString(node.returnType, this.typeAliases)
             : "";
-        let result = this.indentStr(`node ${nodeName}(${params})${returnTypeStr} {\n`);
+        const visibilityStr = this.visibilityToString(node.visibility);
+        let result = this.indentStr(`${visibilityStr}node ${nodeName}(${params})${returnTypeStr} {\n`);
         this.increaseIndent();
         const lines = [];
         for (const stmt of body) {

package/dist/lib/backends/typescriptGenerator.d.ts

@@ -6,7 +6,7 @@ import { AccessExpression, DotFunctionCall, DotProperty, IndexAccess } from "../
 import { AgencyArray, AgencyObject } from "../types/dataStructures.js";
 import { FunctionCall, FunctionDefinition } from "../types/function.js";
 import { IfElse } from "../types/ifElse.js";
-import { ImportNodeStatement, ImportStatement, ImportToolStatement } from "../types/importStatement.js";
+import { ImportNameType, ImportNodeStatement, ImportStatement, ImportToolStatement } from "../types/importStatement.js";
 import { MatchBlock } from "../types/matchBlock.js";
 import { ReturnStatement } from "../types/returnStatement.js";
 import { UsesTool } from "../types/tools.js";
@@ -68,6 +68,7 @@ export declare class TypeScriptGenerator extends BaseGenerator {
         prompt: PromptLiteral;
     }): string;
     protected processImportStatement(node: ImportStatement): string;
+    protected processImportNameType(node: ImportNameType): string;
     protected processImportNodeStatement(node: ImportNodeStatement): string;
     protected processImportToolStatement(node: ImportToolStatement): string;
     protected processWhileLoop(node: WhileLoop): string;

package/dist/lib/backends/typescriptGenerator.js

@@ -479,7 +479,18 @@ export class TypeScriptGenerator extends BaseGenerator {
         });
     }
     processImportStatement(node) {
-        return `import ${node.importedNames} from "${node.modulePath.replace(/\.agency$/, ".js")}";`;
+        const importedNames = node.importedNames.map((name) => this.processImportNameType(name));
+        return `import ${importedNames.join(", ")} from "${node.modulePath.replace(/\.agency$/, ".js")}";`;
+    }
+    processImportNameType(node) {
+        switch (node.type) {
+            case "namedImport":
+                return `{ ${node.importedNames.join(", ")} }`;
+            case "namespaceImport":
+                return `* as ${node.importedNames}`;
+            case "defaultImport":
+                return `${node.importedNames}`;
+        }
     }
     processImportNodeStatement(node) {
         return ""; // handled in preprocess in graphgenerator

package/dist/lib/cli/test.js

@@ -18,7 +18,7 @@ function writeTestCase(agencyFilename, nodeName, input, expectedOutput, evaluati
         tests = JSON.parse(fs.readFileSync(testFilePath, "utf-8"));
     }
     else {
-        tests = { sourceFile: agencyFilename, tests: [] };
+        tests = { sourceFile: path.basename(agencyFilename), tests: [] };
     }
     const testCase = {
         nodeName,

package/dist/lib/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./parser.js";
 export * from "./types.js";
 export * from "./backends/index.js";
+export * from "./simplemachine/index.js";
+export * from "./statelogClient.js";

package/dist/lib/index.js

@@ -1,3 +1,5 @@
 export * from "./parser.js";
 export * from "./types.js";
 export * from "./backends/index.js";
+export * from "./simplemachine/index.js";
+export * from "./statelogClient.js";

package/dist/lib/parsers/function.js

@@ -100,4 +100,5 @@ export const syncFunctionParser = (input) => {
     return mappedParser(input);
 };
 export const functionParser = or(asyncFunctionParser, syncFunctionParser, _functionParser);
-export const graphNodeParser = trace("graphNodeParser", seqC(set("type", "graphNode"), str("node"), many1(space), capture(many1Till(char("(")), "nodeName"), char("("), optionalSpaces, capture(sepBy(comma, or(functionParameterParserWithTypeHint, functionParameterParser)), "parameters"), optionalSpaces, char(")"), optionalSpaces, capture(optional(functionReturnTypeParser), "returnType"), optionalSpaces, char("{"), optionalSpacesOrNewline, capture(bodyParser, "body"), optionalSpaces, char("}"), optionalSemicolon));
+const visibilityParser = or(str("public"), str("private"), succeed(undefined));
+export const graphNodeParser = trace("graphNodeParser", seqC(set("type", "graphNode"), capture(visibilityParser, "visibility"), optionalSpaces, str("node"), many1(space), capture(many1Till(char("(")), "nodeName"), char("("), optionalSpaces, capture(sepBy(comma, or(functionParameterParserWithTypeHint, functionParameterParser)), "parameters"), optionalSpaces, char(")"), optionalSpaces, capture(optional(functionReturnTypeParser), "returnType"), optionalSpaces, char("{"), optionalSpacesOrNewline, capture(bodyParser, "body"), optionalSpaces, char("}"), optionalSemicolon));

package/dist/lib/parsers/importStatement.js

@@ -1,4 +1,4 @@
-import { alphanum, capture, captureCaptures, char, many1Till, many1WithJoin, map, newline, oneOf, optional, or, parseError, sepBy1, seqC, set, spaces, str, trace, } from "tarsec";
+import { alphanum, capture, captureCaptures, char, many1Till, many1WithJoin, map, newline, oneOf, optional, or, parseError, sepBy, sepBy1, seqC, set, spaces, str, trace, } from "tarsec";
 import { optionalSemicolon } from "./parserUtils.js";
 import { comma, optionalSpaces } from "./utils.js";
 // Helper parser for quoted file paths - supports both single and double quotes
@@ -7,4 +7,8 @@ const singleQuotedPath = seqC(char("'"), capture(many1Till(char("'")), "path"),
 const quotedPath = map(or(doubleQuotedPath, singleQuotedPath), (res) => res.path);
 export const importNodeStatmentParser = trace("importNodeStatement", seqC(set("type", "importNodeStatement"), str("import"), spaces, or(str("nodes"), str("node")), captureCaptures(parseError("expected a statement of the form `import nodes { x, y } from 'filename.agency'`", spaces, char("{"), optionalSpaces, capture(sepBy1(comma, many1WithJoin(alphanum)), "importedNodes"), optionalSpaces, char("}"), spaces, str("from"), spaces, capture(quotedPath, "agencyFile"), optionalSemicolon, optional(newline)))));
 export const importToolStatmentParser = trace("importToolStatement", seqC(set("type", "importToolStatement"), str("import"), spaces, or(str("tools"), str("tool")), captureCaptures(parseError("expected a statement of the form `import tools { x, y } from 'filename.agency'`", spaces, char("{"), optionalSpaces, capture(sepBy1(comma, many1WithJoin(alphanum)), "importedTools"), optionalSpaces, char("}"), spaces, str("from"), spaces, capture(quotedPath, "agencyFile"), optionalSemicolon, optional(newline)))));
-export const importStatmentParser = trace("importStatement", seqC(set("type", "importStatement"), str("import"), captureCaptures(parseError("expected a statement of the form `import { x, y } from 'filename'`", spaces, capture(many1Till(str("from")), "importedNames"), str("from"), spaces, oneOf(`'"`), capture(many1Till(oneOf(`'"`)), "modulePath"), oneOf(`'"`), optionalSemicolon, optional(newline)))));
+const namedImportParser = trace("namedImportParser", seqC(char("{"), optionalSpaces, capture(sepBy1(comma, many1WithJoin(alphanum)), "importedNames"), optionalSpaces, char("}"), set("type", "namedImport")));
+const namespaceImportParser = trace("namespaceImportParser", seqC(many1Till(spaces), spaces, str("as"), spaces, capture(many1WithJoin(alphanum), "importedNames"), set("type", "namespaceImport")));
+const defaultImportParser = trace("defaultImportParser", seqC(capture(many1WithJoin(alphanum), "importedNames"), set("type", "defaultImport")));
+const importNameTypeParser = sepBy(comma, or(namedImportParser, namespaceImportParser, defaultImportParser));
+export const importStatmentParser = trace("importStatement", seqC(set("type", "importStatement"), str("import"), captureCaptures(parseError("expected a statement of the form `import { x, y } from 'filename'`", spaces, capture(importNameTypeParser, "importedNames"), spaces, str("from"), spaces, oneOf(`'"`), capture(many1Till(oneOf(`'"`)), "modulePath"), oneOf(`'"`), optionalSemicolon, optional(newline)))));

package/dist/lib/parsers/importStatement.test.js

@@ -1,249 +1,147 @@
 import { describe, it, expect } from "vitest";
 import { importStatmentParser, importNodeStatmentParser, importToolStatmentParser, } from "./importStatement.js";
 describe("importStatmentParser", () => {
-    const testCases = [
-        // Unquoted module paths are no longer supported (start with "import" -> throw)
-        {
-            input: "import foo from bar;",
-            expected: { success: false },
-            throws: true,
-        },
-        {
-            input: "import myModule from path/to/module;",
-            expected: { success: false },
-            throws: true,
-        },
-        // Module paths with double quotes
-        {
-            input: 'import foo from "bar";',
-            expected: {
-                success: true,
-                result: {
-                    type: "importStatement",
-                    importedNames: "foo ",
-                    modulePath: "bar",
-                },
-            },
-        },
-        {
-            input: 'import foo from "./local/path.js";',
-            expected: {
-                success: true,
-                result: {
-                    type: "importStatement",
-                    importedNames: "foo ",
-                    modulePath: "./local/path.js",
-                },
-            },
-        },
-        {
-            input: 'import bar from "../utils/helper.js";',
-            expected: {
-                success: true,
-                result: {
-                    type: "importStatement",
-                    importedNames: "bar ",
-                    modulePath: "../utils/helper.js",
-                },
-            },
-        },
-        {
-            input: 'import { useState } from "react";',
-            expected: {
-                success: true,
-                result: {
-                    type: "importStatement",
-                    importedNames: "{ useState } ",
-                    modulePath: "react",
-                },
-            },
-        },
-        // Module paths with single quotes
-        {
-            input: "import foo from 'bar';",
-            expected: {
-                success: true,
-                result: {
-                    type: "importStatement",
-                    importedNames: "foo ",
-                    modulePath: "bar",
-                },
-            },
-        },
-        {
-            input: "import test from './module.js';",
-            expected: {
-                success: true,
-                result: {
-                    type: "importStatement",
-                    importedNames: "test ",
-                    modulePath: "./module.js",
-                },
-            },
-        },
-        // Without semicolon - unquoted paths no longer supported (start with "import" -> throw)
-        {
-            input: "import foo from bar\n",
-            expected: { success: false },
-            throws: true,
-        },
-        {
-            input: "import test from module",
-            expected: { success: false },
-            throws: true,
-        },
-        {
-            input: 'import foo from "bar"\n',
-            expected: {
-                success: true,
-                result: {
-                    type: "importStatement",
-                    importedNames: "foo ",
-                    modulePath: "bar",
-                },
-            },
-        },
-        // Multiple imported names (destructured imports) - unquoted paths no longer supported (start with "import" -> throw)
-        {
-            input: "import { foo, bar } from module;",
-            expected: { success: false },
-            throws: true,
-        },
-        {
-            input: 'import { foo, bar, baz } from "myModule";',
-            expected: {
-                success: true,
-                result: {
-                    type: "importStatement",
-                    importedNames: "{ foo, bar, baz } ",
-                    modulePath: "myModule",
-                },
-            },
-        },
-        // Default and named imports
-        {
-            input: 'import React, { useState } from "react";',
-            expected: {
-                success: true,
-                result: {
-                    type: "importStatement",
-                    importedNames: "React, { useState } ",
-                    modulePath: "react",
-                },
-            },
-        },
-        // Namespace imports
-        {
-            input: 'import * as utils from "utils";',
-            expected: {
-                success: true,
-                result: {
-                    type: "importStatement",
-                    importedNames: "* as utils ",
-                    modulePath: "utils",
-                },
-            },
-        },
-        // Scoped packages
-        {
-            input: 'import { Parser } from "@typescript-eslint/parser";',
-            expected: {
-                success: true,
-                result: {
-                    type: "importStatement",
-                    importedNames: "{ Parser } ",
-                    modulePath: "@typescript-eslint/parser",
-                },
-            },
-        },
-        // Spaces around keywords - unquoted paths no longer supported (start with "import" -> throw)
-        {
-            input: "import   foo   from   bar;",
-            expected: { success: false },
-            throws: true,
-        },
-        // Edge cases - single character names with unquoted path (start with "import" -> throw)
-        {
-            input: "import x from y;",
-            expected: { success: false },
-            throws: true,
-        },
-        {
-            input: 'import x from "y";',
-            expected: {
-                success: true,
-                result: {
-                    type: "importStatement",
-                    importedNames: "x ",
-                    modulePath: "y",
-                },
-            },
-        },
-        // Complex paths - unquoted paths no longer supported (start with "import" -> throw)
-        {
-            input: "import foo from ../../../utils/helpers;",
-            expected: { success: false },
-            throws: true,
-        },
-        {
-            input: 'import foo from "../../../utils/helpers.js";',
-            expected: {
-                success: true,
-                result: {
-                    type: "importStatement",
-                    importedNames: "foo ",
-                    modulePath: "../../../utils/helpers.js",
-                },
-            },
-        },
-        // Aliased imports
-        {
-            input: 'import { foo as bar } from "module";',
-            expected: {
-                success: true,
-                result: {
-                    type: "importStatement",
-                    importedNames: "{ foo as bar } ",
-                    modulePath: "module",
-                },
-            },
-        },
-        // Failure cases - missing keywords (don't start with "import" -> don't throw)
-        { input: "foo from bar;", expected: { success: false }, throws: false },
-        { input: "from bar;", expected: { success: false }, throws: false },
-        { input: "import foo bar;", expected: { success: false }, throws: true },
-        // Failure cases - missing parts (start with "import" -> throw)
-        { input: "import from bar;", expected: { success: false }, throws: true },
-        { input: "import foo from;", expected: { success: false }, throws: true },
-        { input: "import;", expected: { success: false }, throws: true },
-        // Failure cases - empty input (doesn't start with "import" -> don't throw)
-        { input: "", expected: { success: false }, throws: false },
-        // Failure cases - just keyword
-        { input: "import", expected: { success: false }, throws: true },
-        { input: "from", expected: { success: false }, throws: false },
-    ];
-    testCases.forEach(({ input, expected, throws }) => {
-        if (expected.success) {
-            it(`should parse "${input}" successfully`, () => {
-                const result = importStatmentParser(input);
-                expect(result.success).toBe(true);
-                if (result.success) {
-                    expect(result.result).toEqual(expected.result);
-                }
+    // Default imports
+    it('should parse: import foo from "./foo.ts"', () => {
+        const result = importStatmentParser('import foo from "./foo.ts"');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result).toEqual({
+                type: "importStatement",
+                importedNames: [{ type: "defaultImport", importedNames: "foo" }],
+                modulePath: "./foo.ts",
             });
         }
-        else if (throws) {
-            it(`should fail to parse "${input}"`, () => {
-                expect(() => importStatmentParser(input)).toThrow();
+    });
+    // Named imports
+    it('should parse: import { foo } from "./foo.ts"', () => {
+        const result = importStatmentParser('import { foo } from "./foo.ts"');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result).toEqual({
+                type: "importStatement",
+                importedNames: [{ type: "namedImport", importedNames: ["foo"] }],
+                modulePath: "./foo.ts",
             });
         }
-        else {
-            it(`should fail to parse "${input}"`, () => {
-                const result = importStatmentParser(input);
-                expect(result.success).toBe(false);
+    });
+    // Default + named imports
+    it('should parse: import foo, { bar } from "./foo.ts"', () => {
+        const result = importStatmentParser('import foo, { bar } from "./foo.ts"');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result).toEqual({
+                type: "importStatement",
+                importedNames: [
+                    { type: "defaultImport", importedNames: "foo" },
+                    { type: "namedImport", importedNames: ["bar"] },
+                ],
+                modulePath: "./foo.ts",
+            });
+        }
+    });
+    // Namespace imports
+    it('should parse: import * as foo from "./foo.ts"', () => {
+        const result = importStatmentParser('import * as foo from "./foo.ts"');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result).toEqual({
+                type: "importStatement",
+                importedNames: [{ type: "namespaceImport", importedNames: "foo" }],
+                modulePath: "./foo.ts",
+            });
+        }
+    });
+    // Default + namespace imports
+    it('should parse: import foo, * as bar from "./foo.ts"', () => {
+        const result = importStatmentParser('import foo, * as bar from "./foo.ts"');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result).toEqual({
+                type: "importStatement",
+                importedNames: [
+                    { type: "defaultImport", importedNames: "foo" },
+                    { type: "namespaceImport", importedNames: "bar" },
+                ],
+                modulePath: "./foo.ts",
+            });
+        }
+    });
+    // .agency file imports
+    it('should parse: import foo from "./foo.agency"', () => {
+        const result = importStatmentParser('import foo from "./foo.agency"');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result).toEqual({
+                type: "importStatement",
+                importedNames: [{ type: "defaultImport", importedNames: "foo" }],
+                modulePath: "./foo.agency",
             });
         }
     });
+    it('should parse: import { foo } from "./foo.agency"', () => {
+        const result = importStatmentParser('import { foo } from "./foo.agency"');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result).toEqual({
+                type: "importStatement",
+                importedNames: [{ type: "namedImport", importedNames: ["foo"] }],
+                modulePath: "./foo.agency",
+            });
+        }
+    });
+    // node/tool imports are handled by their own parsers, not importStatmentParser
+    it('should not parse: import node { foo } from "./foo.agency"', () => {
+        expect(() => importStatmentParser('import node { foo } from "./foo.agency"')).toThrow();
+    });
+    it('should not parse: import tool { foo } from "./foo.agency"', () => {
+        expect(() => importStatmentParser('import tool { foo } from "./foo.agency"')).toThrow();
+    });
+    // Multiple named imports
+    it('should parse: import { foo, bar, baz } from "myModule"', () => {
+        const result = importStatmentParser('import { foo, bar, baz } from "myModule"');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result).toEqual({
+                type: "importStatement",
+                importedNames: [
+                    { type: "namedImport", importedNames: ["foo", "bar", "baz"] },
+                ],
+                modulePath: "myModule",
+            });
+        }
+    });
+    // With semicolons
+    it('should parse imports with semicolons', () => {
+        const result = importStatmentParser('import foo from "./foo.ts";');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result.modulePath).toBe("./foo.ts");
+        }
+    });
+    // With single quotes
+    it("should parse imports with single quotes", () => {
+        const result = importStatmentParser("import foo from './foo.ts'");
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result.modulePath).toBe("./foo.ts");
+        }
+    });
+    // Failure cases
+    it("should fail on empty input", () => {
+        const result = importStatmentParser("");
+        expect(result.success).toBe(false);
+    });
+    it("should fail on non-import input", () => {
+        const result = importStatmentParser("foo from bar;");
+        expect(result.success).toBe(false);
+    });
+    it("should throw on unquoted paths", () => {
+        expect(() => importStatmentParser("import foo from bar;")).toThrow();
+    });
+    it("should throw on missing parts", () => {
+        expect(() => importStatmentParser("import foo from;")).toThrow();
+    });
 });
 describe("importNodeStatmentParser", () => {
     const testCases = [

package/dist/lib/simplemachine/error.d.ts

@@ -0,0 +1,3 @@
+export declare class SimpleMachineError extends Error {
+    constructor(message: string);
+}

package/dist/lib/simplemachine/error.js

@@ -0,0 +1,6 @@
+export class SimpleMachineError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SimpleMachineError";
+    }
+}

package/dist/lib/simplemachine/graph.d.ts

@@ -0,0 +1,37 @@
+import { ConditionalFunc, Edge, SimpleMachineConfig } from "./types.js";
+export declare class GoToNode<T> {
+    to: string;
+    data: T;
+    constructor(to: string, data: T);
+}
+export declare function goToNode<T>(to: string, data: T): GoToNode<T>;
+export declare class SimpleMachine<T> {
+    private nodes;
+    private edges;
+    private config;
+    private statelogClient;
+    private nodesTraversed;
+    constructor(config?: SimpleMachineConfig<T>);
+    node(id: string, func: (data: T) => Promise<T | GoToNode<T>>): void;
+    edge(from: string, to: string): void;
+    conditionalEdge<const Adjacent extends string>(from: string, adjacentNodes: readonly Adjacent[], to?: ConditionalFunc<T, Adjacent>): void;
+    debug(message: string, data?: T): void;
+    getNodesTraversed(): readonly string[];
+    run(startId: string, input: T): Promise<T>;
+    runAndValidate(nodeFunc: (data: T) => Promise<T | GoToNode<T>>, currentId: string, _data: T, retries?: number): Promise<T | GoToNode<T>>;
+    prettyPrint(): void;
+    prettyPrintEdge(edge: Edge<T, string>): string;
+    toMermaid(): string;
+    merge(another: SimpleMachine<T>): void;
+    toJSON(): {
+        nodes: string[];
+        edges: Record<string, string[]>;
+        config: {
+            debug: {
+                log?: boolean;
+                logData?: boolean;
+            } | undefined;
+        };
+    };
+    private validateGoToNodeTarget;
+}