@synergenius/flow-weaver 0.3.0 → 0.4.0

package/docs/reference/concepts.md

@@ -0,0 +1,400 @@
+---
+name: Flow Weaver Concepts
+description: Fundamental concepts of Flow Weaver workflows
+keywords: [annotations, nodes, workflows, ports, scopes, STEP, expression, connect, nodeType]
+---
+
+**Source**: https://github.com/synergenius-fw/flow-weaver
+
+# Direct Code Editing
+
+**The code IS the workflow. The visual editor is a view.**
+
+Flow Weaver workflows are plain TypeScript files with JSDoc annotations. You write functions, annotate them, and the compiler handles everything else. No drag-and-drop required.
+
+Here is a complete, minimal workflow written entirely by hand:
+
+```typescript
+/**
+ * @flowWeaver nodeType
+ * @expression
+ * @label Greet
+ * @input name - Name to greet
+ * @output message - Greeting message
+ */
+function greet(name: string): string {
+  return `Hello, ${name}!`;
+}
+
+/**
+ * @flowWeaver nodeType
+ * @expression
+ * @label Uppercase
+ * @input text - Text to transform
+ * @output result - Uppercased text
+ */
+function uppercase(text: string): string {
+  return text.toUpperCase();
+}
+
+/**
+ * @flowWeaver workflow
+ * @param name - Name to greet
+ * @returns result - Uppercased greeting
+ * @node greeter greet
+ * @node transform uppercase
+ * @connect Start.name -> greeter.name
+ * @connect greeter.message -> transform.text
+ * @connect transform.result -> Exit.result
+ * @position greeter 180 0
+ * @position transform 360 0
+ */
+export function greetingWorkflow(
+  execute: boolean,
+  params: { name: string }
+): { onSuccess: boolean; onFailure: boolean; result: string } {
+  return { onSuccess: true, onFailure: false, result: '' };
+}
+```
+
+That is it. Two expression-mode functions, one workflow annotation, zero boilerplate. The compiler infers STEP connections from the data flow -- no `execute`, `onSuccess`, or `onFailure` wiring needed.
+
+---
+
+# Quick Reference
+
+## Topic Navigator
+
+| Task                             | Primary Topic                | Supporting          |
+| -------------------------------- | ---------------------------- | ------------------- |
+| First time? Build a workflow     | `tutorial`                   | concepts            |
+| Build from scratch (experienced) | `iterative-development`      | concepts, export-interface |
+| Scaffold from template           | `scaffold`                   | concepts            |
+| Add iteration/forEach            | `export-interface`           | concepts            |
+| Convert existing functions       | `node-conversion`            | concepts            |
+| Debug validation errors          | `debugging`                  | error-codes         |
+| Look up specific error code      | `error-codes`                | debugging           |
+| Reuse workflow fragments         | `patterns`                   | concepts            |
+| Check annotation syntax          | `jsdoc-grammar`              | concepts            |
+| Look up CLI commands/flags       | `cli-reference`              | —                   |
+| Pull execution, merge strategies | `advanced-annotations`       | jsdoc-grammar       |
+| Compile to Inngest               | `compilation`                | cli-reference       |
+| Deploy to cloud                  | `deployment`                 | compilation         |
+| Use delay/waitForEvent/mocks     | `built-in-nodes`             | debugging           |
+| Publish marketplace packages     | `marketplace`                | —                   |
+
+Use `flow-weaver docs <topic>` to read any topic.
+
+## File Format
+
+Workflows are TypeScript files with JSDoc annotations. Any `.ts`, `.tsx`, `.js`, or `.jsx` file with `@flowWeaver` annotations works.
+
+## CLI Commands
+
+```bash
+flow-weaver validate <file>   # Check for errors (--json for machine parsing)
+flow-weaver compile <file>    # Generate executable code
+flow-weaver run <file>        # Execute a workflow directly. No compile step needed for testing.
+flow-weaver describe <file>   # Get workflow structure as JSON
+flow-weaver watch <file>      # Watch mode
+flow-weaver dev <file>        # Watch + compile + run in one command
+flow-weaver serve [dir]       # HTTP server exposing workflows as endpoints
+flow-weaver diagram <file>    # Generate SVG diagram
+flow-weaver export <file>     # Export as serverless function (lambda/vercel/cloudflare/inngest)
+flow-weaver docs              # Browse documentation
+flow-weaver docs <topic>      # Read a specific topic
+flow-weaver docs search <q>   # Search across all docs
+```
+
+Options: `-w/--workflow-name`, `--json`, `--format text|mermaid`. See `cli-reference` for all commands and flags.
+
+## Core Annotations
+
+### Expression Node Type (Recommended)
+
+> **Tip:** Most nodes should use `@expression` mode. Use normal mode only for custom error handling or void returns.
+
+```typescript
+/**
+ * @flowWeaver nodeType
+ * @expression
+ * @label Display Name
+ * @input inputA - First input
+ * @input inputB - Second input
+ * @output outputName - Description
+ */
+function nodeName(inputA: TypeA, inputB: TypeB): ReturnType {
+  // Pure function logic -- no execute param, no onSuccess/onFailure
+  return result;
+}
+```
+
+Expression nodes are pure functions where:
+
+- No `execute: boolean` parameter -- the runtime handles execution control
+- No `onSuccess`/`onFailure` in return type -- the runtime auto-sets these
+- Function params map directly to `@input` ports
+- Return value maps to `@output` ports:
+  - Primitive/array return -> single output port
+  - Object return `{ a, b }` -> one port per property
+- Best for: transformers, math, utilities, data mapping, async fetchers, API calls
+
+> **Start with expression mode.** Only switch to normal mode when you need explicit branching (`onSuccess`/`onFailure` routing), custom error-with-data patterns, or void returns with side effects.
+
+#### Async Expression Example
+
+```typescript
+/**
+ * @flowWeaver nodeType
+ * @expression
+ * @label Fetch User
+ * @input userId - User ID to look up
+ * @output user - The fetched user object
+ */
+async function fetchUser(userId: string): Promise<User> {
+  const res = await fetch(`/api/users/${userId}`);
+  return await res.json();
+}
+```
+
+### Node Type (Normal Mode)
+
+Use normal mode when you need explicit `try/catch -> onFailure` error handling or `void` returns.
+
+```typescript
+/**
+ * @flowWeaver nodeType
+ * @label Display Name
+ * @input inputA - First input
+ * @input inputB - Second input
+ * @output outputName - Description
+ */
+function nodeName(
+  execute: boolean,
+  inputA: TypeA, // Each @input becomes a direct parameter
+  inputB: TypeB // NOT wrapped in an object
+): { onSuccess: boolean; onFailure: boolean; outputName: Type } {
+  if (!execute) return { onSuccess: false, onFailure: false, outputName: null };
+  return { onSuccess: true, onFailure: false, outputName: result };
+}
+```
+
+### Workflow Export
+
+```typescript
+/**
+ * @flowWeaver workflow
+ * @param inputPort - Description
+ * @returns outputPort - Description
+ * @node instanceId nodeTypeName
+ * @connect Start.inputPort -> instanceId.input
+ * @connect instanceId.output -> Exit.outputPort
+ * @position instanceId 180 0
+ */
+export function workflowName(
+  execute: boolean,
+  params: { inputPort: Type }
+): { onSuccess: boolean; onFailure: boolean; outputPort: Type } {
+  return { onSuccess: true, onFailure: false, outputPort: null };
+}
+```
+
+> STEP connections (`execute`, `onSuccess`, `onFailure`) are auto-wired for expression nodes in linear data flows. Add them explicitly only for branching or normal mode nodes.
+
+### Importing External Functions
+
+Use `@fwImport` to turn npm package functions or local module exports into node types without writing wrapper code:
+
+```typescript
+/**
+ * @flowWeaver workflow
+ * @fwImport npm/lodash/map map from "lodash"
+ * @fwImport local/utils/format formatDate from "./utils"
+ * @node mapper npm/lodash/map
+ * @connect Start.items -> mapper.collection
+ */
+```
+
+- First identifier: node type name (convention: `npm/pkg/fn` or `local/path/fn`)
+- Second identifier: exported function name
+- String: package name or relative path
+
+Imported functions become expression nodes. Port types are inferred from `.d.ts` files when available.
+
+## Mandatory Signatures
+
+### Node Types (direct parameters)
+
+```typescript
+function myNode(execute: boolean, inputA: Type, inputB: Type): {...}
+```
+
+- First param: `execute: boolean`
+- Remaining params: Each `@input` as a direct parameter
+- Return: `{ onSuccess: boolean, onFailure: boolean, ...outputs }`
+
+### Workflow Exports (params object)
+
+```typescript
+export function myWorkflow(execute: boolean, params: { inputA: Type }): {...}
+```
+
+- First param: `execute: boolean`
+- Second param: `params: {...}` object containing all `@param` inputs
+- Return: `{ onSuccess: boolean, onFailure: boolean, ...outputs }`
+
+> **Key difference:** Nodes use direct params, workflows use `params` object.
+
+## Port Types
+
+STRING, NUMBER, BOOLEAN, OBJECT, ARRAY, FUNCTION, ANY, STEP
+
+Types are inferred from TypeScript signature. STEP is for control flow (execute, onSuccess, onFailure).
+
+## Reserved Nodes
+
+- `Start` - Flow entry point (exposes workflow inputs via @param)
+- `Exit` - Flow exit point (receives workflow outputs via @returns)
+
+## Scoped Nodes (Iteration/forEach)
+
+For loops/iteration, use **per-port scopes** with explicit `scope:scopeName` suffixes.
+
+### ForEach Node Pattern
+
+```typescript
+/**
+ * @flowWeaver nodeType
+ * @input items - Array to iterate
+ * @output start scope:processItem - Mandatory: triggers child execute
+ * @output item scope:processItem - Current item to process
+ * @input success scope:processItem - Mandatory: from child onSuccess
+ * @input failure scope:processItem - Mandatory: from child onFailure
+ * @input processed scope:processItem - Result from child
+ * @output results - Collected results
+ */
+function forEach(
+  execute: boolean,
+  items: any[],
+  processItem: (start: boolean, item: any) => { success: boolean; failure: boolean; processed: any }
+) {
+  if (!execute) return { onSuccess: false, onFailure: false, results: [] };
+  const results = items.map((item) => processItem(true, item).processed);
+  return { onSuccess: true, onFailure: false, results };
+}
+```
+
+Key points:
+
+- Scope name (`processItem`) must match callback parameter name
+- Callback parameter is auto-generated, receives scoped ports as args
+- Node iterates by calling callback for each item
+- `start`, `success`, `failure` are mandatory scoped STEP ports
+
+### Workflow Usage
+
+```typescript
+/**
+ * @flowWeaver workflow
+ * @node loop forEach
+ * @node proc processor loop.processItem
+ * @connect Start.execute -> loop.execute
+ * @connect Start.items -> loop.items
+ * @connect loop.start:processItem -> proc.execute
+ * @connect loop.item:processItem -> proc.item
+ * @connect proc.result -> loop.processed:processItem
+ * @connect proc.onSuccess -> loop.success:processItem
+ * @connect proc.onFailure -> loop.failure:processItem
+ * @connect loop.results -> Exit.results
+ * @connect loop.onSuccess -> Exit.onSuccess
+ * @connect loop.onFailure -> Exit.onFailure
+ */
+```
+
+See `flow-weaver docs export-interface` for full scope documentation.
+
+## Node Positioning
+
+Syntax: `@position nodeId x y` (values in pixels, 90px grid)
+
+Default layout:
+
+- Start: -450px (col -5)
+- Exit: 450px (col 5)
+
+Spacing: 180px horizontal (standard), 150px vertical for branches
+
+## Workflow Recipes
+
+### Recipe 1: Build a Workflow from Scratch
+
+```
+1. flow-weaver create workflow sequential my-workflow.ts --preview   # preview the template
+2. Write the file with node types + workflow annotations
+3. flow-weaver validate my-workflow.ts                               # check for errors
+4. Fix any errors, re-validate
+5. flow-weaver compile my-workflow.ts                                # generate executable code
+6. flow-weaver describe my-workflow.ts --format text                 # verify structure
+```
+
+### Recipe 2: Add a Node to Existing Workflow
+
+```
+1. flow-weaver describe my-workflow.ts --format text   # understand current structure
+2. Edit the file: add @flowWeaver nodeType function + @node + @connect annotations
+3. flow-weaver validate my-workflow.ts                 # verify
+```
+
+### Recipe 3: Debug a Broken Workflow
+
+```
+1. flow-weaver validate my-workflow.ts                              # get all errors
+2. flow-weaver describe my-workflow.ts --format text                # get full picture
+3. Fix errors based on error codes (see: flow-weaver docs error-codes)
+```
+
+### Recipe 4: Add Iteration (ForEach)
+
+```
+1. Read: flow-weaver docs export-interface              # scoped port syntax
+2. Edit file: add forEach node type with scope ports
+3. Edit file: add child node with parent scope reference
+4. Edit file: wire scoped connections (:scopeName suffix)
+5. flow-weaver validate my-workflow.ts                  # verify scope wiring
+```
+
+## Workflow Development Process
+
+1. **Create file** - Write TypeScript file with types and node functions
+2. **Add annotations** - `@flowWeaver nodeType` and `@flowWeaver workflow`
+3. **Validate** - `flow-weaver validate <file>`
+4. **Test** - Start with `flow-weaver run <file>` for quick testing. Compile only for production deployment.
+5. **Compile** - `flow-weaver compile <file>`
+6. **Inspect** - `flow-weaver describe <file>` for structure
+
+## Additional Annotations
+
+Beyond the core annotations above, Flow Weaver supports advanced features:
+
+- **`@autoConnect`** — Auto-wire nodes in declaration order (no `@connect` needed)
+- **`@path`** — Declare multi-step routes with `:ok`/`:fail` branching
+- **`@map`** — Shorthand for forEach iteration patterns
+- **`@pullExecution`** — Lazy evaluation (node only executes when output is consumed)
+- **`@executeWhen`** — Control execution strategy (CONJUNCTION/DISJUNCTION/CUSTOM)
+- **`@strictTypes`** — Promote type warnings to errors
+- **Merge strategies** — `[mergeStrategy:COLLECT]` for fan-in patterns
+
+See `advanced-annotations` for full documentation.
+
+## Related Topics
+
+- `cli-reference` - Complete CLI command reference
+- `advanced-annotations` - Pull execution, merge strategies, auto-connect, and more
+- `compilation` - Compilation targets (TypeScript, Inngest) and options
+- `deployment` - Export to cloud, serve mode, OpenAPI
+- `built-in-nodes` - delay, waitForEvent, invokeWorkflow, and mock system
+- `marketplace` - Package ecosystem and plugins
+- `export-interface` - Interface ports and scoped iteration
+- `iterative-development` - Step-by-step building
+- `debugging` - Troubleshooting workflows
+- `error-codes` - Error code reference

package/docs/reference/debugging.md

@@ -0,0 +1,255 @@
+---
+name: Flow Weaver Debugging
+description: Debugging workflows, validation, diagnostics, and error resolution
+keywords: [debug, troubleshooting, errors, WebSocket, diagnostics, runtime, validation, trace]
+---
+
+# Flow Weaver Debugging Guide
+
+For error code lookup, use `flow-weaver docs error-codes`.
+
+---
+
+## Top 5 Errors Quick Fix
+
+| Error                   | Fix                                                             |
+| ----------------------- | --------------------------------------------------------------- |
+| UNKNOWN_NODE_TYPE       | Check spelling, run `flow-weaver describe <file>`               |
+| MISSING_REQUIRED_INPUT  | Add `@connect` or make port optional with `@input [name]`       |
+| STEP_PORT_TYPE_MISMATCH | STEP ports (execute/onSuccess/onFailure) only connect to STEP   |
+| CYCLE_DETECTED          | Use scoped forEach instead of graph loops                       |
+| UNKNOWN_SOURCE_PORT     | Check port name spelling, run `flow-weaver describe <file>`     |
+
+---
+
+## WebSocket Debug Events
+
+Flow Weaver can emit real-time execution events over WebSocket for runtime debugging. This is enabled by compiling without the `--production` flag.
+
+### Enabling Debug Events
+
+```bash
+# Compile the workflow (debug mode is the default)
+flow-weaver compile my-workflow.ts
+
+# Run with WebSocket debug target
+FLOW_WEAVER_DEBUG=ws://localhost:9000 node my-workflow.generated.js
+```
+
+Production builds (`flow-weaver compile --production`) strip all debug event code.
+
+### Event Types
+
+| Event              | Description                  | Key Fields                                |
+| ------------------ | ---------------------------- | ----------------------------------------- |
+| STATUS_CHANGED     | Node execution status change | `id`, `status` (RUNNING/SUCCEEDED/FAILED) |
+| VARIABLE_SET       | Port value set               | `identifier.portName`, `value`            |
+| LOG_ERROR          | Node threw an error          | `id`, `error` message                     |
+| WORKFLOW_COMPLETED | Workflow finished            | `status`, `result`                        |
+
+### WebSocket Message Format
+
+Messages are JSON-encoded with envelope: `{ type: "event", sessionId, event: {...} }`.
+On connection: `{ type: "connect", sessionId, workflowExportName, clientInfo }`.
+
+When a workflow calls another workflow, inner events have `innerFlowInvocation: true`.
+
+---
+
+## Debugging Decision Tree
+
+```
+START: What is the problem?
+|
++-- "Compilation fails" (parse or validation errors)
+|   |
+|   +-- Run: flow-weaver validate <file> --verbose
+|   |
+|   +-- Are there PARSE errors?
+|   |   |
+|   |   +-- YES --> Check annotation syntax:
+|   |   |           - @flowWeaver nodeType / workflow present?
+|   |   |           - @connect format: Source.port -> Target.port ?
+|   |   |           - Function signature: (execute: boolean, ...) => { onSuccess, ... } ?
+|   |   |           - Proper JSDoc comment blocks (/** ... */) not line comments (//)?
+|   |   |
+|   |   +-- NO --> Are there VALIDATION errors?
+|   |       |
+|   |       +-- YES --> Look up the error code: flow-weaver docs error-codes
+|   |       |           Common quick fixes:
+|   |       |           - UNKNOWN_*: Check spelling, use validator suggestions
+|   |       |           - MISSING_REQUIRED_INPUT: Add connection or default
+|   |       |           - CYCLE_DETECTED: Break the loop, use scoped nodes
+|   |       |           - STEP_PORT_TYPE_MISMATCH: Don't mix control/data flow
+|   |       |
+|   |       +-- NO --> Warnings only. Workflow is valid but review warnings.
+|   |                   Common warnings to address:
+|   |                   - UNUSED_NODE: Remove or connect it
+|   |                   - MULTIPLE_EXIT_CONNECTIONS: Use separate exit ports
+|   |                   - TYPE_MISMATCH: Verify data compatibility
+|
++-- "Runtime error" (workflow compiled but fails when executed)
+|   |
+|   +-- Enable WebSocket debugging:
+|   |   FLOW_WEAVER_DEBUG=ws://localhost:9000 node <file>
+|   |
+|   +-- Is the error "Variable not found: X.Y[Z]"?
+|   |   |
+|   |   +-- YES --> A node tried to read a port value that was never set.
+|   |               Causes: upstream node failed silently, connection goes
+|   |               through a branch that was not taken, execution order issue.
+|   |               Check: onSuccess/onFailure path taken by upstream node.
+|   |
+|   |   +-- NO --> Is it a CancellationError?
+|   |       |
+|   |       +-- YES --> The AbortSignal was triggered. Check abort logic.
+|   |       |
+|   |       +-- NO --> Check the LOG_ERROR events for the failing node.
+|   |                   Read the compiled source file to see the actual code.
+|   |                   Common issues:
+|   |                   - NaN from string-to-number coercion
+|   |                   - undefined property access on OBJECT ports
+|   |                   - JSON.parse failure on string-to-object coercion
+|
++-- "Wrong output" (workflow runs but returns unexpected values)
+|   |
+|   +-- Use VARIABLE_SET events to trace data through the graph
+|   |
+|   +-- Check Exit port connections:
+|   |   - Is the correct node connected to the Exit port?
+|   |   - Are there MULTIPLE_EXIT_CONNECTIONS? (only one value used)
+|   |   - Is the Exit port receiving data from the right branch?
+|   |
+|   +-- Check branching:
+|   |   - Which branch was taken (onSuccess vs onFailure)?
+|   |   - Are conditional nodes evaluating as expected?
+|   |
+|   +-- Read the compiled source file to verify wiring
+|
++-- "Node not executing" (node appears to be skipped)
+    |
+    +-- Is the execute port connected?
+    |   - Check: Start.onSuccess -> Node.execute or PreviousNode.onSuccess -> Node.execute
+    |
+    +-- Is the execute signal true?
+    |   - CONJUNCTION strategy: ALL upstream STEP sources must be true
+    |   - DISJUNCTION strategy: ANY upstream STEP source must be true
+    |
+    +-- Is the node on a branch that was not taken?
+    |   - If upstream node failed, onSuccess=false, onFailure=true
+    |   - Nodes on the onSuccess branch will receive execute=false
+    |
+    +-- Is the node in a scope?
+        - Scoped nodes only execute when their parent iterates
+        - Check the parent node's execution and scope function
+```
+
+---
+
+## CLI Debugging Commands
+
+### flow-weaver validate -- Validate a Workflow
+
+The first command to use when something seems wrong. Returns all errors and warnings with codes, messages, and hints.
+
+```bash
+flow-weaver validate src/workflows/my-workflow.ts
+flow-weaver validate src/workflows/my-workflow.ts --json    # machine-readable
+flow-weaver validate src/workflows/my-workflow.ts --verbose  # detailed diagnostics
+```
+
+### flow-weaver describe -- Understand Workflow Structure
+
+Provides a full description of the workflow: nodes, connections, ports, types, and execution graph.
+
+```bash
+flow-weaver describe src/workflows/my-workflow.ts                      # JSON
+flow-weaver describe src/workflows/my-workflow.ts --format text        # human-readable
+flow-weaver describe src/workflows/my-workflow.ts --format mermaid     # diagram
+flow-weaver describe src/workflows/my-workflow.ts --node fetcher1      # focus on a node
+```
+
+### Diagnostic Strategy
+
+1. **flow-weaver validate** -- Get all errors and warnings. Fix errors first.
+2. **flow-weaver describe --format text** -- Full readable summary.
+3. **flow-weaver describe --node <id>** -- Trace data flow for a specific node.
+4. **flow-weaver describe --format mermaid** -- Visual graph for inspection.
+
+---
+
+## Common Error Patterns
+
+### Export Returns null/undefined
+
+**Cause 1: Exit port not connected.** Add `@connect Processor.result -> Exit.output`.
+
+**Cause 2: Multiple connections to same Exit port.** Only one value is used. Use separate Exit ports for each branch.
+
+**Cause 3: Upstream node failed.** Check WebSocket events for `FAILED` status.
+
+### "Variable not found" Runtime Error
+
+Execution context tried to read a variable never written. Source node didn't execute, failed, or an execution index mismatch. Ensure execution path guarantees source runs before consumer.
+
+### STEP vs Data Port Confusion
+
+The three control flow ports (`execute`, `onSuccess`, `onFailure`) are STEP type. They only connect to other STEP ports. All other ports are data ports and only connect to data ports.
+
+```typescript
+// Control flow (STEP to STEP):
+/** @connect NodeA.onSuccess -> NodeB.execute */
+// Data flow (DATA to DATA):
+/** @connect NodeA.result -> NodeB.inputData */
+```
+
+### Scoped Node Children Not Executing
+
+Scoped ports use direction inversion: scoped OUTPUTS = data parent sends to children, scoped INPUTS = data parent receives from children. Ensure child instances have `parent` set to the scoped node.
+
+### Workflow Compiles but Generated Code Has Issues
+
+1. Read the compiled source file to inspect actual code (compilation modifies the file in-place)
+2. Check connection wiring and variable resolution order
+3. Re-compile without `--production` to enable tracing
+
+---
+
+## Mock System for Built-in Nodes
+
+When testing workflows that use `delay`, `waitForEvent`, or `invokeWorkflow`, use mocks to avoid real side effects:
+
+```bash
+flow-weaver run workflow.ts --mocks '{"fast": true, "events": {"app/approved": {"status": "ok"}}}'
+flow-weaver run workflow.ts --mocks-file mocks.json
+```
+
+Mock config structure:
+- `fast: true` — Skip real sleep in `delay` nodes (1ms instead)
+- `events: { "event-name": data }` — Mock event data for `waitForEvent`
+- `invocations: { "function-id": result }` — Mock results for `invokeWorkflow`
+
+See `built-in-nodes` for full documentation on mock configuration and testing patterns.
+
+## Dev Mode
+
+Use `flow-weaver dev` to watch, compile, and run in a single command:
+
+```bash
+flow-weaver dev workflow.ts --params '{"data": "test"}'
+```
+
+This recompiles and re-runs automatically on every file save.
+
+---
+
+## Related Topics
+
+- `error-codes` — Error code reference with fixes
+- `built-in-nodes` — Mock system for delay, waitForEvent, invokeWorkflow
+- `cli-reference` — All CLI commands and flags
+- `advanced-annotations` — Pull execution, merge strategies, and other advanced features
+
+## Still Stuck?
+
+Read the source: https://github.com/synergenius-fw/flow-weaver