@synergenius/flow-weaver 0.2.0

package/dist/cli/templates/workflows/foreach.js

@@ -0,0 +1,143 @@
+/**
+ * ForEach Batch Processing Template
+ * Iterate over array items with scoped ports
+ */
+export const foreachTemplate = {
+    id: 'foreach',
+    name: 'ForEach Batch',
+    description: 'Batch processing with iteration over arrays',
+    category: 'data-processing',
+    generate: (opts) => {
+        const { workflowName, async: isAsync } = opts;
+        const asyncKeyword = isAsync ? 'async ' : '';
+        const returnType = isAsync
+            ? 'Promise<{ onSuccess: boolean; onFailure: boolean; results: any[]; successCount: number; failedCount: number }>'
+            : '{ onSuccess: boolean; onFailure: boolean; results: any[]; successCount: number; failedCount: number }';
+        return `
+/**
+ * Iterates over items and processes each one
+ *
+ * @flowWeaver nodeType
+ * @label For Each Item
+ * @input items [order:1] - Array of items to iterate
+ * @input success scope:processItem [order:0] - From child onSuccess
+ * @input failure scope:processItem [order:1] - From child onFailure
+ * @input result scope:processItem [order:2] - Result from child
+ * @input execute [order:0] - Execute
+ * @output start scope:processItem [order:0] - Triggers child execute
+ * @output item scope:processItem [order:1] - Current item to process
+ * @output results [order:2] - Collected results after iteration
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+function forEachItem(
+  execute: boolean,
+  items: any[],
+  processItem: (start: boolean, item: any) => { success: boolean; failure: boolean; result: any }
+): { onSuccess: boolean; onFailure: boolean; results: any[] } {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, results: [] };
+  }
+
+  const results: any[] = [];
+  for (const item of items) {
+    const r = processItem(true, item);
+    results.push(r.result);
+  }
+
+  return { onSuccess: true, onFailure: false, results };
+}
+
+/**
+ * Processes a single item
+ *
+ * @flowWeaver nodeType
+ * @label Process Item
+ * @input item [order:1] - Item to process
+ * @input execute [order:0] - Execute
+ * @output result [order:2] - Processed result
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+function processItem(
+  execute: boolean,
+  item: any
+): { onSuccess: boolean; onFailure: boolean; result: any } {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, result: null };
+  }
+
+  // TODO: Add your processing logic here
+  const result = { ...item, processed: true };
+
+  return { onSuccess: true, onFailure: false, result };
+}
+
+/**
+ * Aggregates results from iteration
+ *
+ * @flowWeaver nodeType
+ * @label Aggregate Results
+ * @input results [order:1] - Array of processed results
+ * @input execute [order:0] - Execute
+ * @output successCount [order:2] - Number of successes
+ * @output failedCount [order:3] - Number of failures
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+function aggregateResults(
+  execute: boolean,
+  results: any[]
+): { onSuccess: boolean; onFailure: boolean; successCount: number; failedCount: number } {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, successCount: 0, failedCount: 0 };
+  }
+
+  const successCount = results.filter(r => r?.processed).length;
+  const failedCount = results.length - successCount;
+
+  return { onSuccess: true, onFailure: false, successCount, failedCount };
+}
+
+/**
+ * @flowWeaver workflow
+ * @node iterator forEachItem [size: 300 200]
+ * @node processor processItem iterator.processItem
+ * @node aggregator aggregateResults
+ * @position Start -450 0
+ * @position iterator -90 0
+ * @position processor 90 0
+ * @position aggregator 270 0
+ * @position Exit 450 0
+ * @connect Start.execute -> iterator.execute
+ * @connect Start.items -> iterator.items
+ * @connect iterator.start:processItem -> processor.execute
+ * @connect iterator.item:processItem -> processor.item
+ * @connect processor.result -> iterator.result:processItem
+ * @connect processor.onSuccess -> iterator.success:processItem
+ * @connect processor.onFailure -> iterator.failure:processItem
+ * @connect iterator.results -> Exit.results
+ * @connect iterator.results -> aggregator.results
+ * @connect iterator.onSuccess -> aggregator.execute
+ * @connect aggregator.successCount -> Exit.successCount
+ * @connect aggregator.failedCount -> Exit.failedCount
+ * @connect aggregator.onSuccess -> Exit.onSuccess
+ * @connect aggregator.onFailure -> Exit.onFailure
+ * @param execute [order:0] - Execute
+ * @param items [order:1] - Array of items to process
+ * @returns onSuccess [order:0] - On Success
+ * @returns onFailure [order:1] - On Failure
+ * @returns results [order:2] - Processed results
+ * @returns successCount [order:3] - Number of successful items
+ * @returns failedCount [order:4] - Number of failed items
+ */
+export ${asyncKeyword}function ${workflowName}(
+  execute: boolean,
+  params: { items: any[] }
+): ${returnType} {
+  throw new Error("Compile with: flow-weaver compile <file>");
+}
+`.trim();
+    },
+};
+//# sourceMappingURL=foreach.js.map

package/dist/cli/templates/workflows/sequential.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sequential Pipeline Template
+ * Linear data processing: validate -> transform -> output
+ */
+import type { WorkflowTemplate } from '../index.js';
+export declare const sequentialTemplate: WorkflowTemplate;
+//# sourceMappingURL=sequential.d.ts.map

package/dist/cli/templates/workflows/sequential.js

@@ -0,0 +1,198 @@
+/**
+ * Sequential Pipeline Template
+ * Linear data processing: validate -> transform -> output
+ */
+const configSchema = {
+    nodes: {
+        type: 'string',
+        label: 'Node Names',
+        description: 'Comma-separated list of node function names (e.g. "fetch,parse,store")',
+        placeholder: 'validateData,transformData,outputResult',
+    },
+    input: {
+        type: 'string',
+        label: 'Input Port Name',
+        description: 'Name of the input data port',
+        default: 'data',
+        placeholder: 'data',
+    },
+    output: {
+        type: 'string',
+        label: 'Output Port Name',
+        description: 'Name of the output data port',
+        default: 'result',
+        placeholder: 'result',
+    },
+};
+function generateDefaultTemplate(workflowName, asyncKeyword, returnType) {
+    return `
+// Use @expression for pure functions, normal mode for branching
+
+/**
+ * Validates input data
+ * Normal mode: explicit error routing with data on failure
+ *
+ * @flowWeaver nodeType
+ * @label Validate
+ * @input data [order:1] - Data to validate
+ * @input execute [order:0] - Execute
+ * @output data [order:2] - Validated data
+ * @output isValid [order:3] - Validation passed
+ * @output error [order:4] - Validation error message
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+function validateData(
+  execute: boolean,
+  data: any
+): { onSuccess: boolean; onFailure: boolean; data: any; isValid: boolean; error: string | null } {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, data: null, isValid: false, error: null };
+  }
+
+  // TODO: Add validation logic
+  if (!data) {
+    return { onSuccess: false, onFailure: true, data: null, isValid: false, error: "Data is required" };
+  }
+
+  return { onSuccess: true, onFailure: false, data, isValid: true, error: null };
+}
+
+/**
+ * Transforms validated data
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Transform
+ * @input data [order:0] - Data to transform
+ * @output data [order:0] - Transformed data
+ */
+function transformData(data: any): { data: any } {
+  // TODO: Add transformation logic
+  return { data: { ...data, processedAt: new Date().toISOString() } };
+}
+
+/**
+ * Outputs the final result
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label Output
+ * @input data [order:0] - Data to output
+ * @output result [order:0] - Final result
+ */
+function outputResult(data: any): { result: any } {
+  return { result: data };
+}
+
+/**
+ * @flowWeaver workflow
+ * @node validator validateData
+ * @node transformer transformData
+ * @node outputter outputResult
+ * @position Start -600 0
+ * @position validator -300 0
+ * @position transformer 0 0
+ * @position outputter 300 0
+ * @position Exit 600 0
+ * @path Start -> validator -> transformer -> outputter -> Exit
+ * @connect validator.onFailure -> Exit.onFailure
+ * @connect validator.error -> Exit.error
+ * @param execute [order:0] - Execute
+ * @param data [order:1] - Input data
+ * @returns onSuccess [order:0] - On Success
+ * @returns onFailure [order:1] - On Failure
+ * @returns result [order:2] - Processed result
+ * @returns error [order:3] - Error message if failed
+ */
+export ${asyncKeyword}function ${workflowName}(
+  execute: boolean,
+  params: { data: any }
+): ${returnType} {
+  throw new Error("Compile with: flow-weaver compile <file>");
+}
+`.trim();
+}
+function generateCustomTemplate(workflowName, asyncKeyword, returnType, nodeNames, inputPort, outputPort) {
+    // Generate node type functions
+    const nodeTypeDefs = nodeNames.map((name, i) => {
+        const isFirst = i === 0;
+        const isLast = i === nodeNames.length - 1;
+        const inputPortName = isFirst ? inputPort : 'data';
+        const outputPortName = isLast ? outputPort : 'data';
+        return `/**
+ * ${name} step
+ *
+ * @flowWeaver nodeType
+ * @expression
+ * @label ${name.charAt(0).toUpperCase() + name.slice(1)}
+ * @input ${inputPortName} [order:0] - Input data
+ * @output ${outputPortName} [order:0] - Output data
+ */
+function ${name}(${inputPortName}: any): { ${outputPortName}: any } {
+  // TODO: Implement ${name} logic
+  return { ${outputPortName}: ${inputPortName} };
+}`;
+    });
+    // Generate workflow annotations
+    const nodeAnnotations = nodeNames.map((name, i) => ` * @node step${i} ${name}`).join('\n');
+    const spacing = 300;
+    const startX = -(nodeNames.length * (spacing / 2) + spacing / 2);
+    const positionAnnotations = [
+        ` * @position Start ${startX} 0`,
+        ...nodeNames.map((_, i) => ` * @position step${i} ${startX + (i + 1) * spacing} 0`),
+        ` * @position Exit ${startX + (nodeNames.length + 1) * spacing} 0`,
+    ].join('\n');
+    // Build connections using @path sugar
+    const pathNodes = ['Start', ...nodeNames.map((_, i) => `step${i}`), 'Exit'];
+    const connections = [];
+    connections.push(` * @path ${pathNodes.join(' -> ')}`);
+    connections.push(` * @connect step0.onFailure -> Exit.onFailure`);
+    return `${nodeTypeDefs.join('\n\n')}
+
+/**
+ * @flowWeaver workflow
+${nodeAnnotations}
+${positionAnnotations}
+${connections.join('\n')}
+ * @param execute [order:0] - Execute
+ * @param ${inputPort} [order:1] - Input data
+ * @returns onSuccess [order:0] - On Success
+ * @returns onFailure [order:1] - On Failure
+ * @returns ${outputPort} [order:2] - Processed result
+ * @returns error [order:3] - Error message if failed
+ */
+export ${asyncKeyword}function ${workflowName}(
+  execute: boolean,
+  params: { ${inputPort}: any }
+): ${returnType} {
+  throw new Error("Compile with: flow-weaver compile <file>");
+}`.trim();
+}
+export const sequentialTemplate = {
+    id: 'sequential',
+    name: 'Sequential Pipeline',
+    description: 'Linear pipeline: validate -> transform -> output',
+    category: 'data-processing',
+    configSchema,
+    generate: (opts) => {
+        const { workflowName, async: isAsync, config } = opts;
+        const asyncKeyword = isAsync ? 'async ' : '';
+        const returnType = isAsync
+            ? 'Promise<{ onSuccess: boolean; onFailure: boolean; result: any; error?: string }>'
+            : '{ onSuccess: boolean; onFailure: boolean; result: any; error?: string }';
+        // If custom nodes are provided, generate custom template
+        const customNodes = config?.nodes;
+        const inputPort = config?.input || 'data';
+        const outputPort = config?.output || 'result';
+        if (customNodes && Array.isArray(customNodes) && customNodes.length > 0) {
+            return generateCustomTemplate(workflowName, asyncKeyword, returnType, customNodes, inputPort, outputPort);
+        }
+        // If only input/output are customized but no custom nodes
+        if (inputPort !== 'data' || outputPort !== 'result') {
+            return generateCustomTemplate(workflowName, asyncKeyword, returnType, ['validateData', 'transformData', 'outputResult'], inputPort, outputPort);
+        }
+        return generateDefaultTemplate(workflowName, asyncKeyword, returnType);
+    },
+};
+//# sourceMappingURL=sequential.js.map

package/dist/cli/templates/workflows/webhook.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Webhook Template
+ * HTTP-triggered workflow entry point
+ */
+import type { WorkflowTemplate } from "../index.js";
+export declare const webhookTemplate: WorkflowTemplate;
+//# sourceMappingURL=webhook.d.ts.map

package/dist/cli/templates/workflows/webhook.js

@@ -0,0 +1,161 @@
+/**
+ * Webhook Template
+ * HTTP-triggered workflow entry point
+ */
+export const webhookTemplate = {
+    id: "webhook",
+    name: "Webhook Handler",
+    description: "HTTP-triggered workflow with request/response handling",
+    category: "integration",
+    generate: (opts) => {
+        const { workflowName, async: isAsync } = opts;
+        const asyncKeyword = isAsync ? "async " : "";
+        const returnType = isAsync
+            ? "Promise<{ onSuccess: boolean; onFailure: boolean; statusCode: number; body: any }>"
+            : "{ onSuccess: boolean; onFailure: boolean; statusCode: number; body: any }";
+        return `
+/**
+ * Validates incoming webhook request
+ *
+ * @flowWeaver nodeType
+ * @label Validate Request
+ * @input headers [order:1] - Request headers
+ * @input body [order:2] - Request body
+ * @input execute [order:0] - Execute
+ * @output isValid [order:2] - Whether request is valid
+ * @output validatedData [order:3] - Validated request data
+ * @output error [order:4] - Validation error message
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+function validateRequest(
+  execute: boolean,
+  headers: Record<string, string>,
+  body: any
+): { onSuccess: boolean; onFailure: boolean; isValid: boolean; validatedData: any; error: string } {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, isValid: false, validatedData: null, error: "" };
+  }
+
+  // TODO: Add your validation logic
+  // Example: Check API key, validate body schema, etc.
+  const apiKey = headers["x-api-key"] || headers["authorization"];
+
+  if (!apiKey) {
+    return { onSuccess: false, onFailure: true, isValid: false, validatedData: null, error: "Missing API key" };
+  }
+
+  return { onSuccess: true, onFailure: false, isValid: true, validatedData: body, error: "" };
+}
+
+/**
+ * Processes the webhook payload
+ *
+ * @flowWeaver nodeType
+ * @label Process Payload
+ * @input data [order:1] - Validated payload data
+ * @input execute [order:0] - Execute
+ * @output result [order:2] - Processing result
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+function processPayload(
+  execute: boolean,
+  data: any
+): { onSuccess: boolean; onFailure: boolean; result: any } {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, result: null };
+  }
+
+  // TODO: Add your business logic
+  const result = {
+    processed: true,
+    timestamp: new Date().toISOString(),
+    data
+  };
+
+  return { onSuccess: true, onFailure: false, result };
+}
+
+/**
+ * Formats the HTTP response
+ *
+ * @flowWeaver nodeType
+ * @label Format Response
+ * @input result [order:1] - Processing result
+ * @input error [order:2] - Error message if any
+ * @input isSuccess [order:3] - Whether processing succeeded
+ * @input execute [order:0] - Execute
+ * @output statusCode [order:2] - HTTP status code
+ * @output body [order:3] - Response body
+ * @output onSuccess [order:0] - On Success
+ * @output onFailure [order:1] - On Failure
+ */
+function formatResponse(
+  execute: boolean,
+  result: any,
+  error: string,
+  isSuccess: boolean
+): { onSuccess: boolean; onFailure: boolean; statusCode: number; body: any } {
+  if (!execute) {
+    return { onSuccess: false, onFailure: false, statusCode: 0, body: null };
+  }
+
+  if (isSuccess) {
+    return {
+      onSuccess: true,
+      onFailure: false,
+      statusCode: 200,
+      body: { success: true, data: result }
+    };
+  } else {
+    return {
+      onSuccess: true,
+      onFailure: false,
+      statusCode: 400,
+      body: { success: false, error: error || "Processing failed" }
+    };
+  }
+}
+
+/**
+ * @flowWeaver workflow
+ * @node validator validateRequest
+ * @node processor processPayload
+ * @node responder formatResponse
+ * @position Start -450 0
+ * @position validator -180 0
+ * @position processor 90 -60
+ * @position responder 270 0
+ * @position Exit 450 0
+ * @connect Start.execute -> validator.execute
+ * @connect Start.headers -> validator.headers
+ * @connect Start.body -> validator.body
+ * @connect validator.onSuccess -> processor.execute
+ * @connect validator.validatedData -> processor.data
+ * @connect validator.error -> responder.error
+ * @connect processor.onSuccess -> responder.execute
+ * @connect processor.result -> responder.result
+ * @connect validator.isValid -> responder.isSuccess
+ * @connect responder.statusCode -> Exit.statusCode
+ * @connect responder.body -> Exit.body
+ * @connect responder.onSuccess -> Exit.onSuccess
+ * @connect responder.onFailure -> Exit.onFailure
+ * @param execute [order:0] - Execute
+ * @param headers [order:1] - HTTP request headers
+ * @param body [order:2] - HTTP request body
+ * @returns onSuccess [order:0] - On Success
+ * @returns onFailure [order:1] - On Failure
+ * @returns statusCode [order:2] - HTTP response status code
+ * @returns body [order:3] - HTTP response body
+ */
+export ${asyncKeyword}function ${workflowName}(
+  execute: boolean,
+  params: { headers: Record<string, string>; body: any }
+): ${returnType} {
+  throw new Error("Compile with: flow-weaver compile <file>");
+}
+`.trim();
+    },
+};
+//# sourceMappingURL=webhook.js.map

package/dist/cli/utils/logger.d.ts

@@ -0,0 +1,15 @@
+/**
+ * CLI logging utility with colors and formatting
+ */
+export declare const logger: {
+    info(message: string): void;
+    success(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+    debug(message: string): void;
+    log(message: string): void;
+    newline(): void;
+    section(title: string): void;
+    progress(current: number, total: number, item: string): void;
+};
+//# sourceMappingURL=logger.d.ts.map

package/dist/cli/utils/logger.js

@@ -0,0 +1,46 @@
+/* eslint-disable no-console */
+/**
+ * CLI logging utility with colors and formatting
+ */
+// ANSI color support - respects NO_COLOR env var and non-TTY
+const USE_COLOR = !process.env.NO_COLOR && process.stdout.isTTY !== false;
+const RESET = USE_COLOR ? '\x1b[0m' : '';
+const GREEN = USE_COLOR ? '\x1b[32m' : '';
+const RED = USE_COLOR ? '\x1b[31m' : '';
+const YELLOW = USE_COLOR ? '\x1b[33m' : '';
+const BLUE = USE_COLOR ? '\x1b[34m' : '';
+const BOLD = USE_COLOR ? '\x1b[1m' : '';
+const DIM = USE_COLOR ? '\x1b[2m' : '';
+export const logger = {
+    info(message) {
+        console.log(`${BLUE}ℹ ${message}${RESET}`);
+    },
+    success(message) {
+        console.log(`${GREEN}✓ ${message}${RESET}`);
+    },
+    error(message) {
+        console.error(`${RED}✗ ${message}${RESET}`);
+    },
+    warn(message) {
+        console.warn(`${YELLOW}⚠ ${message}${RESET}`);
+    },
+    debug(message) {
+        if (process.env.DEBUG) {
+            console.log(`${DIM}🔍 ${message}${RESET}`);
+        }
+    },
+    log(message) {
+        console.log(message);
+    },
+    newline() {
+        console.log();
+    },
+    section(title) {
+        console.log();
+        console.log(`${BOLD}━━━ ${title} ━━━${RESET}`);
+    },
+    progress(current, total, item) {
+        console.log(`[${current}/${total}] ${item}`);
+    },
+};
+//# sourceMappingURL=logger.js.map

package/dist/constants.d.ts

@@ -0,0 +1,100 @@
+/**
+ * # Flow Weaver Constants
+ *
+ * This module defines reserved names and constants used throughout the Flow Weaver system.
+ *
+ * ## Scoped Port Architecture
+ *
+ * Scoped ports enable iteration patterns (forEach, map) WITHOUT graph cycles.
+ * The key insight is that port directions are INVERTED for scoped ports:
+ *
+ * ```
+ * ┌─────────────────────────────────────────────────────────────────────┐
+ * │                    SCOPED PORT DIRECTION MAPPING                    │
+ * ├─────────────────┬──────────┬────────────────────────────────────────┤
+ * │ Scoped OUTPUT   │ Parent→  │ Parameters TO children (start, item)   │
+ * │ Scoped INPUT    │ →Parent  │ Returns FROM children (success, result)│
+ * └─────────────────┴──────────┴────────────────────────────────────────┘
+ * ```
+ *
+ * **Why this inversion?**
+ * - Scoped OUTPUT ports (like `start`, `item`) are data the parent SENDS to nested nodes
+ * - Scoped INPUT ports (like `success`, `result`) are data the parent RECEIVES from nested nodes
+ * - The loop iteration happens in the parent's imperative code, not as graph cycles
+ *
+ * ## Mandatory Scoped Ports
+ *
+ * Every scoped node must have these ports for each scope it declares:
+ * - `start` (OUTPUT) - Triggers scope execution, passed as first param
+ * - `success` (INPUT) - Signals successful completion from child
+ * - `failure` (INPUT) - Signals failure from child
+ *
+ * ## Example: forEach Node
+ *
+ * ```typescript
+ * @scope processItem
+ * @output start scope:processItem    // OUTPUT → function param (triggers iteration)
+ * @output item scope:processItem     // OUTPUT → function param (current item)
+ * @input success scope:processItem   // INPUT → return value (completion signal)
+ * @input processed scope:processItem // INPUT → return value (processed data)
+ *
+ * function forEach(execute, items, processItem) {
+ *   const results = [];
+ *   for (const item of items) {
+ *     const r = processItem(true, item); // Calls generated closure
+ *     if (r.success) results.push(r.processed);
+ *   }
+ *   return { onSuccess: true, results };
+ * }
+ * ```
+ */
+export declare const RESERVED_NODE_NAMES: {
+    readonly START: "Start";
+    readonly EXIT: "Exit";
+};
+export declare const RESERVED_PORT_NAMES: {
+    readonly EXECUTE: "execute";
+    readonly ON_SUCCESS: "onSuccess";
+    readonly ON_FAILURE: "onFailure";
+};
+export declare const SCOPED_PORT_NAMES: {
+    readonly START: "start";
+    readonly SUCCESS: "success";
+    readonly FAILURE: "failure";
+};
+export declare const EXECUTION_STRATEGIES: {
+    readonly CONJUNCTION: "CONJUNCTION";
+    readonly DISJUNCTION: "DISJUNCTION";
+    readonly CUSTOM: "CUSTOM";
+};
+export declare const BRANCHING_STRATEGIES: {
+    readonly VALUE_BASED: "value-based";
+    readonly EXCEPTION_BASED: "exception-based";
+    readonly NONE: "none";
+};
+export type ReservedNodeName = (typeof RESERVED_NODE_NAMES)[keyof typeof RESERVED_NODE_NAMES];
+export type ReservedPortName = (typeof RESERVED_PORT_NAMES)[keyof typeof RESERVED_PORT_NAMES];
+export type ExecutionStrategy = (typeof EXECUTION_STRATEGIES)[keyof typeof EXECUTION_STRATEGIES];
+export type BranchingStrategyType = (typeof BRANCHING_STRATEGIES)[keyof typeof BRANCHING_STRATEGIES];
+export declare function isReservedNodeName(name: string): name is ReservedNodeName;
+export declare function isReservedPortName(name: string): name is ReservedPortName;
+export declare function isStartNode(nodeName: string): boolean;
+export declare function isExitNode(nodeName: string): boolean;
+export declare function isSpecialNode(nodeName: string): boolean;
+export declare function isExecutePort(portName: string): boolean;
+export declare function isSuccessPort(portName: string): boolean;
+export declare function isFailurePort(portName: string): boolean;
+export declare function isScopedStartPort(portName: string): boolean;
+export declare function isScopedSuccessPort(portName: string): boolean;
+export declare function isScopedFailurePort(portName: string): boolean;
+export declare function isScopedMandatoryPort(portName: string): boolean;
+export declare function isControlFlowPort(portName: string): boolean;
+/**
+ * Check if a port definition represents a scoped port
+ * Scoped ports are FUNCTION type with a scope attribute
+ */
+export declare function isScopedPort(portDef: {
+    dataType: string;
+    scope?: string;
+}): boolean;
+//# sourceMappingURL=constants.d.ts.map