diff --git a/.github/workflows/classic-ci.yml b/.github/workflows/classic-ci.yml
new file mode 100644
index 0000000..059ea84
--- /dev/null
+++ b/.github/workflows/classic-ci.yml
@@ -0,0 +1,30 @@
+name: FluNET.Classic CI
+
+on:
+ push:
+ branches:
+ - 'classic/**'
+ pull_request:
+ branches:
+ - 'classic/main'
+
+jobs:
+ build-test:
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v4
+
+ - name: Setup .NET
+ uses: actions/setup-dotnet@v4
+ with:
+ dotnet-version: '8.0.x'
+
+ - name: Restore
+ run: dotnet restore FluNET.sln
+
+ - name: Build
+ run: dotnet build FluNET.sln --configuration Release --no-restore
+
+ - name: Test
+ run: dotnet test FluNET.sln --configuration Release --no-build --verbosity normal
diff --git a/src/FluNET.CLI/FluNET.CLI.csproj b/src/FluNET.CLI/FluNET.CLI.csproj
new file mode 100644
index 0000000..42d1564
--- /dev/null
+++ b/src/FluNET.CLI/FluNET.CLI.csproj
@@ -0,0 +1,13 @@
+
+
+ Exe
+ net8.0
+ enable
+ enable
+ flu
+
+
+
+
+
+
diff --git a/src/FluNET.CLI/Program.cs b/src/FluNET.CLI/Program.cs
new file mode 100644
index 0000000..08078e1
--- /dev/null
+++ b/src/FluNET.CLI/Program.cs
@@ -0,0 +1,199 @@
+using FluNET.Compilation;
+using FluNET.Diagnostics;
+using FluNET.Execution;
+using FluNET.Execution.Capabilities;
+using FluNET.Language;
+
+return await FluCli.RunAsync(args);
+
+internal static class FluCli
+{
+ public static async Task RunAsync(string[] args)
+ {
+ var registry = new LanguageRegistry();
+ LanguageBuildResult language = registry.Build();
+
+ if (args.Length == 0 || IsHelp(args[0]))
+ {
+ PrintHelp();
+ return 0;
+ }
+
+ string command = args[0].ToLowerInvariant();
+ return command switch
+ {
+ "verbs" => ShowVerbs(language.Snapshot),
+ "verb" => ShowVerb(language.Snapshot, args),
+ "modules" => ShowModules(language.Snapshot),
+ "language" => ShowLanguage(language),
+ "check" => Check(language.Snapshot, args),
+ "explain" => Explain(language.Snapshot, args),
+ "run" => await RunScriptAsync(language.Snapshot, args),
+ _ => Unknown(command)
+ };
+ }
+
+ private static int ShowVerbs(LanguageSnapshot language)
+ {
+ foreach (IGrouping group in language.Verbs
+ .OrderBy(x => x.Text)
+ .GroupBy(x => x.Text, StringComparer.OrdinalIgnoreCase))
+ Console.WriteLine($"{group.Key,-16} {group.Count()} implementation(s)");
+ return 0;
+ }
+
+ private static int ShowVerb(LanguageSnapshot language, string[] args)
+ {
+ if (args.Length < 2) return Missing("verb keyword");
+ Console.WriteLine(LanguageIntrospection.ExplainVerb(language, args[1]));
+ return language.GetVerbOverloads(args[1]).Count > 0 ? 0 : 2;
+ }
+
+ private static int ShowModules(LanguageSnapshot language)
+ {
+ if (language.Modules.Count == 0)
+ {
+ Console.WriteLine("No explicit language modules registered.");
+ return 0;
+ }
+
+ foreach (ModuleDescriptor module in language.Modules.OrderBy(x => x.ModuleName))
+ Console.WriteLine($"{module.ModuleName} {module.Version}");
+ return 0;
+ }
+
+ private static int ShowLanguage(LanguageBuildResult language)
+ {
+ PrintDiagnostics(language.Diagnostics);
+ Console.WriteLine(LanguageIntrospection.ToJson(language.Snapshot));
+ return language.Success ? 0 : 2;
+ }
+
+ private static int Check(LanguageSnapshot language, string[] args)
+ {
+ if (!TryReadScript(args, out string? source, out int error)) return error;
+ ClassicCompilation compilation = new ClassicCompiler(language).Compile(source!);
+ PrintDiagnostics(compilation.Diagnostics);
+ if (compilation.Success)
+ Console.WriteLine($"OK: {compilation.Pipelines.Count} pipeline(s).");
+ return compilation.Success ? 0 : 2;
+ }
+
+ private static int Explain(LanguageSnapshot language, string[] args)
+ {
+ if (!TryReadScript(args, out string? source, out int error)) return error;
+ ClassicCompilation compilation = new ClassicCompiler(language).Compile(source!);
+ PrintDiagnostics(compilation.Diagnostics);
+ if (!compilation.Success) return 2;
+
+ for (int p = 0; p < compilation.Pipelines.Count; p++)
+ {
+ Console.WriteLine($"Pipeline {p + 1}:");
+ foreach (var sentence in compilation.Pipelines[p].Sentences)
+ {
+ Console.WriteLine($" {sentence.Verb.Text} -> {sentence.Verb.VerbType.FullName}");
+ Console.WriteLine($" result: {sentence.ResultType?.FullName ?? "void/unknown"}");
+ Console.WriteLine($" cost: {sentence.BindingCost}");
+ foreach (var role in sentence.Roles)
+ Console.WriteLine($" {role.Descriptor.Kind}: {role.Descriptor.ValueType.Name} ({role.Descriptor.Direction}, {role.Descriptor.Cardinality})");
+ }
+ }
+ return 0;
+ }
+
+ private static async Task RunScriptAsync(LanguageSnapshot language, string[] args)
+ {
+ if (!TryReadScript(args, out string? source, out int error)) return error;
+
+ string[] allowed = ReadAllowedCapabilities(args);
+ ICapabilityPolicy capabilities = allowed.Length == 0
+ ? AllowAllCapabilityPolicy.Instance
+ : new ExplicitCapabilityPolicy(allowed);
+
+ var engine = new ClassicScriptEngine(language, capabilities: capabilities);
+ try
+ {
+ ClassicScriptResult result = await engine.RunAsync(source!);
+ PrintDiagnostics(result.Compilation.Diagnostics);
+ if (!result.Success) return 2;
+ if (result.Result != null) Console.WriteLine(result.Result);
+ return 0;
+ }
+ catch (CapabilityDeniedException ex)
+ {
+ Console.Error.WriteLine(ex.Message);
+ return 3;
+ }
+ catch (Exception ex)
+ {
+ Console.Error.WriteLine($"Runtime error: {ex.Message}");
+ return 4;
+ }
+ }
+
+ private static string[] ReadAllowedCapabilities(string[] args)
+ {
+ int index = Array.FindIndex(args, x => x.Equals("--allow", StringComparison.OrdinalIgnoreCase));
+ if (index < 0 || index + 1 >= args.Length) return [];
+ return args[index + 1].Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+ }
+
+ private static bool TryReadScript(string[] args, out string? source, out int error)
+ {
+ source = null;
+ error = 0;
+ if (args.Length < 2)
+ {
+ error = Missing("script file");
+ return false;
+ }
+
+ string file = args[1];
+ if (!File.Exists(file))
+ {
+ Console.Error.WriteLine($"Script not found: {file}");
+ error = 2;
+ return false;
+ }
+
+ source = File.ReadAllText(file);
+ return true;
+ }
+
+ private static void PrintDiagnostics(IEnumerable diagnostics)
+ {
+ foreach (Diagnostic diagnostic in diagnostics)
+ {
+ string location = diagnostic.Span is null ? string.Empty : $" [{diagnostic.Span.Start}..{diagnostic.Span.End})";
+ Console.Error.WriteLine($"{diagnostic.Code} {diagnostic.Severity}: {diagnostic.Message}{location}");
+ }
+ }
+
+ private static int Unknown(string command)
+ {
+ Console.Error.WriteLine($"Unknown command: {command}");
+ PrintHelp();
+ return 2;
+ }
+
+ private static int Missing(string value)
+ {
+ Console.Error.WriteLine($"Missing {value}.");
+ return 2;
+ }
+
+ private static bool IsHelp(string value) => value is "-h" or "--help" or "help";
+
+ private static void PrintHelp()
+ {
+ Console.WriteLine("FluNET.Classic 0.1");
+ Console.WriteLine();
+ Console.WriteLine(" flu verbs");
+ Console.WriteLine(" flu verb ");
+ Console.WriteLine(" flu modules");
+ Console.WriteLine(" flu language");
+ Console.WriteLine(" flu check ");
+ Console.WriteLine(" flu explain ");
+ Console.WriteLine(" flu run [--allow capability1,capability2]");
+ }
+}
diff --git a/src/FluNet.Engine/Binding/BoundNodes.cs b/src/FluNet.Engine/Binding/BoundNodes.cs
new file mode 100644
index 0000000..b387232
--- /dev/null
+++ b/src/FluNet.Engine/Binding/BoundNodes.cs
@@ -0,0 +1,28 @@
+using FluNET.Diagnostics;
+using FluNET.Language;
+using FluNET.Language.Metadata;
+using FluNET.Syntax.Ast;
+
+namespace FluNET.Binding;
+
+public sealed record BoundValue(
+ ExpressionNode Source,
+ Type ExpectedType,
+ Type ActualType,
+ object? ConstantValue,
+ int ConversionCost,
+ ValueConversion? Conversion = null);
+
+public sealed record BoundRole(ClauseDescriptor Descriptor, IReadOnlyList Values);
+public sealed record BoundSentence(VerbDescriptor Verb, ConstructorDescriptor? Constructor, IReadOnlyList Roles, Type? ResultType, int BindingCost);
+public sealed record BoundPipeline(IReadOnlyList Sentences, Type? ResultType);
+
+public sealed record BindingResult(T? Value, IReadOnlyList Diagnostics)
+{
+ public bool Success => Value != null && Diagnostics.All(x => x.Severity != DiagnosticSeverity.Error);
+}
+
+public sealed record BindingContext(
+ IReadOnlyDictionary? VariableTypes = null,
+ Type? PipelineType = null,
+ IServiceProvider? Services = null);
diff --git a/src/FluNet.Engine/Binding/ExpressionRuntimeEvaluator.cs b/src/FluNet.Engine/Binding/ExpressionRuntimeEvaluator.cs
new file mode 100644
index 0000000..1f12230
--- /dev/null
+++ b/src/FluNet.Engine/Binding/ExpressionRuntimeEvaluator.cs
@@ -0,0 +1,67 @@
+using FluNET.Syntax.Ast;
+using System.Collections.Concurrent;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace FluNET.Binding;
+
+///
+/// Evaluates bound expression sources against runtime variables/pipeline values.
+/// Reflection accessors are cached per CLR type/property.
+///
+public sealed class ExpressionRuntimeEvaluator
+{
+ private static readonly Regex Interpolation = new(@"\[(?[A-Za-z_][A-Za-z0-9_\.]*)\]", RegexOptions.Compiled);
+ private readonly ConcurrentDictionary<(Type Type, string Property), PropertyInfo?> _properties = new();
+
+ public object? Evaluate(ExpressionNode expression, ActivationContext context)
+ {
+ return expression switch
+ {
+ VariableExpression variable => ResolveVariable(variable.Name, context),
+ PropertyExpression property => ResolveProperty(property, context),
+ PipelineValueExpression => context.PipelineValue,
+ InterpolatedStringExpression interpolated => Interpolate(interpolated.Template, context),
+ LiteralExpression literal => literal.Value,
+ ReferenceExpression reference => reference.Reference,
+ _ => null
+ };
+ }
+
+ private object? ResolveVariable(string name, ActivationContext context)
+ {
+ if (context.Variables != null && context.Variables.TryGetValue(name, out object? value))
+ return value;
+ throw new InvalidOperationException($"Variable '{name}' has no runtime value.");
+ }
+
+ private object? ResolveProperty(PropertyExpression property, ActivationContext context)
+ {
+ object? target = Evaluate(property.Target, context);
+ if (target == null) return null;
+
+ PropertyInfo? info = _properties.GetOrAdd((target.GetType(), property.Property), key =>
+ key.Type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
+ .FirstOrDefault(x => x.Name.Equals(key.Property, StringComparison.OrdinalIgnoreCase)));
+
+ if (info == null)
+ throw new InvalidOperationException($"Property '{property.Property}' does not exist on '{target.GetType().FullName}'.");
+
+ return info.GetValue(target);
+ }
+
+ private string Interpolate(string template, ActivationContext context) =>
+ Interpolation.Replace(template, match =>
+ {
+ ExpressionNode expression = ParsePath(match.Groups["path"].Value);
+ return Evaluate(expression, context)?.ToString() ?? string.Empty;
+ });
+
+ private static ExpressionNode ParsePath(string path)
+ {
+ string[] parts = path.Split('.', StringSplitOptions.RemoveEmptyEntries);
+ ExpressionNode current = new VariableExpression(parts[0]);
+ for (int i = 1; i < parts.Length; i++) current = new PropertyExpression(current, parts[i]);
+ return current;
+ }
+}
diff --git a/src/FluNet.Engine/Binding/IValueConverter.cs b/src/FluNet.Engine/Binding/IValueConverter.cs
new file mode 100644
index 0000000..c69ab99
--- /dev/null
+++ b/src/FluNet.Engine/Binding/IValueConverter.cs
@@ -0,0 +1,82 @@
+using System.Globalization;
+
+namespace FluNET.Binding;
+
+public sealed record ValueConversion(
+ Type SourceType,
+ Type TargetType,
+ int Cost,
+ Func Apply);
+
+public interface IValueConverter
+{
+ Type SourceType { get; }
+ Type TargetType { get; }
+ int Cost { get; }
+ object? Convert(object? value);
+}
+
+public abstract class ValueConverter(int cost = 2) : IValueConverter
+{
+ public Type SourceType => typeof(TFrom);
+ public Type TargetType => typeof(TTo);
+ public int Cost { get; } = cost;
+ public object? Convert(object? value) => value is null ? default(TTo) : Convert((TFrom)value);
+ protected abstract TTo Convert(TFrom value);
+}
+
+///
+/// Runtime conversion graph used after a value already has a CLR type. This is separate
+/// from textual IValueResolver resolution.
+///
+public sealed class ValueConversionRegistry
+{
+ private static readonly HashSet NumericTypes =
+ [typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint), typeof(long), typeof(ulong), typeof(float), typeof(double), typeof(decimal)];
+
+ private readonly List _converters = [];
+
+ public ValueConversionRegistry Add(IValueConverter converter)
+ {
+ ArgumentNullException.ThrowIfNull(converter);
+ _converters.Insert(0, converter);
+ return this;
+ }
+
+ public bool TryGet(Type sourceType, Type targetType, out ValueConversion? conversion)
+ {
+ if (sourceType == targetType)
+ {
+ conversion = new(sourceType, targetType, 0, value => value);
+ return true;
+ }
+
+ if (targetType.IsAssignableFrom(sourceType))
+ {
+ conversion = new(sourceType, targetType, 1, value => value);
+ return true;
+ }
+
+ Type sourceActual = Nullable.GetUnderlyingType(sourceType) ?? sourceType;
+ Type targetActual = Nullable.GetUnderlyingType(targetType) ?? targetType;
+
+ IValueConverter? custom = _converters
+ .Where(x => x.SourceType.IsAssignableFrom(sourceActual) && targetActual.IsAssignableFrom(x.TargetType))
+ .OrderBy(x => x.Cost)
+ .FirstOrDefault();
+ if (custom != null)
+ {
+ conversion = new(sourceType, targetType, custom.Cost, custom.Convert);
+ return true;
+ }
+
+ if (NumericTypes.Contains(sourceActual) && NumericTypes.Contains(targetActual))
+ {
+ conversion = new(sourceType, targetType, 2, value => value is null ? null : System.Convert.ChangeType(value, targetActual, CultureInfo.InvariantCulture));
+ return true;
+ }
+
+ conversion = null;
+ return false;
+ }
+}
diff --git a/src/FluNet.Engine/Binding/IValueResolver.cs b/src/FluNet.Engine/Binding/IValueResolver.cs
index ac80753..fcf8f83 100644
--- a/src/FluNet.Engine/Binding/IValueResolver.cs
+++ b/src/FluNet.Engine/Binding/IValueResolver.cs
@@ -1,13 +1,16 @@
namespace FluNET.Binding;
///
-/// Converts the textual surface language into CLR values. This separates value
-/// binding (file.txt -> FileInfo, URL -> Uri) from verb execution.
+/// Converts textual surface values into CLR values. Context-aware overloads preserve
+/// compatibility with simple resolvers while allowing role/verb-sensitive resolution.
///
public interface IValueResolver
{
bool CanResolve(Type targetType);
object? Resolve(string value, Type targetType);
+
+ bool CanResolve(Type targetType, ResolutionContext context) => CanResolve(targetType);
+ object? Resolve(string value, Type targetType, ResolutionContext context) => Resolve(value, targetType);
}
public abstract class ValueResolver : IValueResolver
diff --git a/src/FluNet.Engine/Binding/ReflectionValueResolver.cs b/src/FluNet.Engine/Binding/ReflectionValueResolver.cs
new file mode 100644
index 0000000..1a6a834
--- /dev/null
+++ b/src/FluNet.Engine/Binding/ReflectionValueResolver.cs
@@ -0,0 +1,63 @@
+using System.ComponentModel;
+using System.Globalization;
+using System.Reflection;
+
+namespace FluNET.Binding;
+
+///
+/// Convention fallback for CLR types. Resolution order is enum, TryParse, Parse,
+/// TypeConverter and finally a public T(string) constructor.
+///
+public sealed class ReflectionValueResolver : IValueResolver
+{
+ public bool CanResolve(Type targetType) => targetType != typeof(string);
+
+ public object? Resolve(string value, Type targetType) =>
+ Resolve(value, targetType, new ResolutionContext(targetType));
+
+ public object? Resolve(string value, Type targetType, ResolutionContext context)
+ {
+ Type actualType = Nullable.GetUnderlyingType(targetType) ?? targetType;
+
+ if (actualType.IsEnum)
+ return Enum.Parse(actualType, value, ignoreCase: true);
+
+ MethodInfo? tryParse = actualType.GetMethods(BindingFlags.Public | BindingFlags.Static)
+ .FirstOrDefault(method =>
+ {
+ ParameterInfo[] parameters = method.GetParameters();
+ return method.Name == "TryParse"
+ && method.ReturnType == typeof(bool)
+ && parameters.Length == 2
+ && parameters[0].ParameterType == typeof(string)
+ && parameters[1].IsOut
+ && parameters[1].ParameterType.GetElementType() == actualType;
+ });
+
+ if (tryParse != null)
+ {
+ object?[] args = [value, null];
+ if (tryParse.Invoke(null, args) is true)
+ return args[1];
+ }
+
+ MethodInfo? parse = actualType.GetMethod(
+ "Parse",
+ BindingFlags.Public | BindingFlags.Static,
+ binder: null,
+ types: [typeof(string)],
+ modifiers: null);
+ if (parse != null && actualType.IsAssignableFrom(parse.ReturnType))
+ return parse.Invoke(null, [value]);
+
+ TypeConverter converter = TypeDescriptor.GetConverter(actualType);
+ if (converter.CanConvertFrom(typeof(string)))
+ return converter.ConvertFrom(null, context.EffectiveCulture, value);
+
+ ConstructorInfo? stringConstructor = actualType.GetConstructor([typeof(string)]);
+ if (stringConstructor != null)
+ return stringConstructor.Invoke([value]);
+
+ return null;
+ }
+}
diff --git a/src/FluNet.Engine/Binding/ResolutionContext.cs b/src/FluNet.Engine/Binding/ResolutionContext.cs
new file mode 100644
index 0000000..63ac2c4
--- /dev/null
+++ b/src/FluNet.Engine/Binding/ResolutionContext.cs
@@ -0,0 +1,16 @@
+using FluNET.Language;
+using System.Globalization;
+
+namespace FluNET.Binding;
+
+public sealed record ResolutionContext(
+ Type ExpectedType,
+ ClauseKind? Role = null,
+ VerbDescriptor? Verb = null,
+ QualifierDescriptor? Qualifier = null,
+ IServiceProvider? Services = null,
+ CultureInfo? Culture = null,
+ IReadOnlyDictionary? Variables = null)
+{
+ public CultureInfo EffectiveCulture => Culture ?? CultureInfo.InvariantCulture;
+}
diff --git a/src/FluNet.Engine/Binding/SemanticBinder.cs b/src/FluNet.Engine/Binding/SemanticBinder.cs
new file mode 100644
index 0000000..6974489
--- /dev/null
+++ b/src/FluNet.Engine/Binding/SemanticBinder.cs
@@ -0,0 +1,118 @@
+using FluNET.Diagnostics;
+using FluNET.Language;
+using FluNET.Language.Metadata;
+using FluNET.Syntax.Ast;
+using FluNET.Syntax.Core;
+using System.Reflection;
+
+namespace FluNET.Binding;
+
+public sealed class SemanticBinder
+{
+ private readonly LanguageSnapshot _language;
+ private readonly ValueResolverRegistry _resolvers;
+ private readonly ValueConversionRegistry _conversions;
+
+ public SemanticBinder(LanguageSnapshot language, ValueResolverRegistry? resolvers = null, ValueConversionRegistry? conversions = null)
+ {
+ _language = language; _resolvers = resolvers ?? new ValueResolverRegistry(); _conversions = conversions ?? new ValueConversionRegistry();
+ }
+
+ public BindingResult BindSentence(SentenceNode sentence, BindingContext? context = null)
+ {
+ context ??= new BindingContext();
+ IReadOnlyList overloads = _language.GetVerbOverloads(sentence.Verb).Where(x => QualifierMatches(sentence.Qualifier, x)).ToArray();
+ if (overloads.Count == 0) return Failure("FLU2001", $"Unknown verb or qualifier combination '{sentence.Verb}{(sentence.Qualifier is null ? "" : " " + sentence.Qualifier)}'.", sentence.Span);
+
+ var candidates = new List();
+ foreach (VerbDescriptor overload in overloads)
+ {
+ IReadOnlyList patterns = overload.Patterns.Count > 0 ? overload.Patterns : [new VerbPatternDescriptor(overload.Pattern, overload.Constructors.FirstOrDefault())];
+ foreach (VerbPatternDescriptor pattern in patterns) { BoundSentence? candidate = TryBindPattern(sentence, overload, pattern, context); if (candidate != null) candidates.Add(candidate); }
+ }
+
+ if (candidates.Count == 0) return Failure("FLU2101", $"No overload of '{sentence.Verb}' matches this sentence. Available: {string.Join(", ", overloads.SelectMany(FormatSignatures))}.", sentence.Span);
+ int bestCost = candidates.Min(x => x.BindingCost); BoundSentence[] best = candidates.Where(x => x.BindingCost == bestCost).ToArray();
+ if (best.Length > 1) return Failure("FLU2102", $"Ambiguous '{sentence.Verb}' sentence. Matching overloads: {string.Join(", ", best.Select(x => FormatSignature(x.Verb.Text, x.Roles.Select(r => r.Descriptor))))}.", sentence.Span);
+ return new(best[0], []);
+ }
+
+ public BindingResult BindPipeline(PipelineNode pipeline, BindingContext? context = null)
+ {
+ context ??= new BindingContext(); var bound = new List(); var diagnostics = new List();
+ var variableTypes = context.VariableTypes != null ? new Dictionary(context.VariableTypes, StringComparer.OrdinalIgnoreCase) : new Dictionary(StringComparer.OrdinalIgnoreCase);
+ Type? pipelineType = context.PipelineType;
+ foreach (SentenceNode sentence in pipeline.Sentences)
+ {
+ BindingResult result = BindSentence(sentence, context with { PipelineType = pipelineType, VariableTypes = variableTypes }); diagnostics.AddRange(result.Diagnostics); if (!result.Success || result.Value == null) return new(null, diagnostics);
+ bound.Add(result.Value); pipelineType = result.Value.ResultType;
+ foreach (BoundRole role in result.Value.Roles.Where(x => x.Descriptor.Direction is RoleDirection.Output or RoleDirection.InputOutput))
+ foreach (BoundValue value in role.Values) if (value.Source is VariableExpression variable) variableTypes[variable.Name] = role.Descriptor.ValueType;
+ }
+ return new(new BoundPipeline(bound, pipelineType), diagnostics);
+ }
+
+ private BoundSentence? TryBindPattern(SentenceNode sentence, VerbDescriptor verb, VerbPatternDescriptor patternDescriptor, BindingContext context)
+ {
+ SentencePattern pattern = patternDescriptor.Pattern; var remaining = sentence.Clauses.GroupBy(x => x.Kind).ToDictionary(x => x.Key, x => new Queue(x)); var roles = new List(); int cost = 0;
+ foreach (ClauseDescriptor expected in pattern.Clauses)
+ {
+ int minimum = expected.Cardinality is RoleCardinality.One or RoleCardinality.OneOrMore ? 1 : 0; bool repeated = expected.Cardinality is RoleCardinality.ZeroOrMore or RoleCardinality.OneOrMore; var values = new List();
+ if (remaining.TryGetValue(expected.Kind, out Queue? queue) && queue.Count > 0)
+ {
+ if (repeated && expected.ElementType != null) { BoundValue? collection = TryBindRepeatedValues(queue, expected, verb, context); if (collection == null) return null; values.Add(collection); cost += collection.ConversionCost; }
+ else { BoundValue? value = TryBindValue(queue.Dequeue().Value, expected, verb, context); if (value == null) return null; values.Add(value); cost += value.ConversionCost; }
+ }
+ if (values.Count < minimum) { BoundValue? implicitPipeline = TryBindPipelineValue(expected, context); if (implicitPipeline != null) { values.Add(implicitPipeline); cost += implicitPipeline.ConversionCost; } }
+ if (values.Count < minimum) return null; roles.Add(new BoundRole(expected, values));
+ }
+ if (remaining.Values.Any(queue => queue.Count > 0)) return null;
+ return new BoundSentence(verb, patternDescriptor.Constructor, roles, verb.ResultType, cost);
+ }
+
+ private bool QualifierMatches(string? qualifierText, VerbDescriptor verb)
+ {
+ if (qualifierText == null) return true; if (!_language.TryGetQualifier(qualifierText, out QualifierDescriptor? qualifier) || qualifier == null) return false; if (qualifier.ValueType == null) return true;
+ IEnumerable candidateTypes = verb.Patterns.SelectMany(p => p.Pattern.Clauses).Where(x => x.Kind == ClauseKind.What).Select(x => x.ValueType); if (!candidateTypes.Any()) candidateTypes = verb.Pattern.Clauses.Where(x => x.Kind == ClauseKind.What).Select(x => x.ValueType); if (verb.ResultType != null) candidateTypes = candidateTypes.Prepend(verb.ResultType);
+ return candidateTypes.Any(type => type == qualifier.ValueType || qualifier.ValueType.IsAssignableFrom(type) || type.IsAssignableFrom(qualifier.ValueType) || (type.IsArray && type.GetElementType() == qualifier.ValueType));
+ }
+
+ private BoundValue? TryBindRepeatedValues(Queue queue, ClauseDescriptor expected, VerbDescriptor verb, BindingContext context)
+ {
+ ClauseNode[] clauses = queue.ToArray(); queue.Clear(); string[] texts = clauses.Select(x => x.Value switch { LiteralExpression l => l.Value, ReferenceExpression r => r.Reference, _ => null }).Where(x => x != null).Cast().ToArray(); if (texts.Length != clauses.Length) return null;
+ if (!_resolvers.TryResolveMany(texts, expected.ValueType, new ResolutionContext(expected.ValueType, expected.Kind, verb, Services: context.Services), out object? collection)) return null;
+ ExpressionNode source = clauses.Length == 1 ? clauses[0].Value : new InterpolatedStringExpression(string.Join(" ", texts)); return new(source, expected.ValueType, collection?.GetType() ?? expected.ValueType, collection, 2);
+ }
+
+ private BoundValue? TryBindValue(ExpressionNode expression, ClauseDescriptor expected, VerbDescriptor verb, BindingContext context)
+ {
+ if (expected.Direction == RoleDirection.Output && expression is VariableExpression output) return new(output, expected.ValueType, expected.ValueType, null, 0);
+ if (expression is PipelineValueExpression) return BindKnownType(expression, context.PipelineType, expected.ValueType, null);
+ if (expression is VariableExpression or PropertyExpression)
+ {
+ Type? actualType = InferExpressionType(expression, context); return BindKnownType(expression, actualType, expected.ValueType, null);
+ }
+ if (expression is InterpolatedStringExpression interpolated && expected.ValueType == typeof(string)) return new(interpolated, typeof(string), typeof(string), null, 0);
+ string? text = expression switch { LiteralExpression l => l.Value, ReferenceExpression r => r.Reference, _ => null }; if (text == null) return null;
+ if (_resolvers.TryResolve(text, expected.ValueType, new ResolutionContext(expected.ValueType, expected.Kind, verb, Services: context.Services), out object? value)) return new(expression, expected.ValueType, value?.GetType() ?? expected.ValueType, value, expected.ValueType == typeof(string) ? 0 : 2);
+ return null;
+ }
+
+ private Type? InferExpressionType(ExpressionNode expression, BindingContext context)
+ {
+ if (expression is VariableExpression variable) { context.VariableTypes?.TryGetValue(variable.Name, out Type? type); return type; }
+ if (expression is PipelineValueExpression) return context.PipelineType;
+ if (expression is PropertyExpression property)
+ {
+ Type? targetType = InferExpressionType(property.Target, context); if (targetType == null) return null;
+ PropertyInfo? info = targetType.GetProperties(BindingFlags.Public | BindingFlags.Instance).FirstOrDefault(x => x.Name.Equals(property.Property, StringComparison.OrdinalIgnoreCase)); return info?.PropertyType;
+ }
+ return null;
+ }
+
+ private BoundValue? TryBindPipelineValue(ClauseDescriptor expected, BindingContext context) => expected.Direction == RoleDirection.Output || context.PipelineType == null ? null : BindKnownType(new PipelineValueExpression(), context.PipelineType, expected.ValueType, null);
+ private BoundValue? BindKnownType(ExpressionNode source, Type? actualType, Type expectedType, object? value) { if (actualType == null || !_conversions.TryGet(actualType, expectedType, out ValueConversion? conversion) || conversion == null) return null; return new(source, expectedType, actualType, value, conversion.Cost, conversion); }
+ private static BindingResult Failure(string code, string message, TextSpan? span = null) => new(null, [Diagnostic.Error(code, message, span)]);
+ private static IEnumerable FormatSignatures(VerbDescriptor verb) { IReadOnlyList patterns = verb.Patterns.Count > 0 ? verb.Patterns : [new VerbPatternDescriptor(verb.Pattern, null)]; return patterns.Select(x => FormatSignature(verb.Text, x.Pattern.Clauses)); }
+ private static string FormatSignature(string verb, IEnumerable clauses) => $"{verb} {string.Join(" ", clauses.Select(x => $"{x.Kind.ToString().ToUpperInvariant()}<{(x.ValueType.IsArray ? x.ValueType.GetElementType()!.Name + "[]" : x.ValueType.Name)}>"))}".TrimEnd();
+}
diff --git a/src/FluNet.Engine/Binding/ValueResolverRegistry.cs b/src/FluNet.Engine/Binding/ValueResolverRegistry.cs
index a841e8f..493a381 100644
--- a/src/FluNet.Engine/Binding/ValueResolverRegistry.cs
+++ b/src/FluNet.Engine/Binding/ValueResolverRegistry.cs
@@ -1,20 +1,24 @@
+using System.Collections;
using System.Globalization;
+using System.Reflection;
namespace FluNET.Binding;
///
-/// CLR-backed value binding used by the future binder and available to verbs during migration.
+/// Ordered CLR value-resolution pipeline. Explicit resolvers run first; reflection
+/// conventions are the final fallback.
///
public sealed class ValueResolverRegistry
{
private readonly List _resolvers = [];
+ private readonly IValueResolver _reflectionFallback = new ReflectionValueResolver();
public ValueResolverRegistry()
{
- Add(new StringResolver());
- Add(new FileInfoResolver());
- Add(new UriResolver());
- Add(new PrimitiveResolver());
+ _resolvers.Add(new StringResolver());
+ _resolvers.Add(new FileInfoResolver());
+ _resolvers.Add(new UriResolver());
+ _resolvers.Add(new PrimitiveResolver());
}
public ValueResolverRegistry Add(IValueResolver resolver)
@@ -24,21 +28,25 @@ public ValueResolverRegistry Add(IValueResolver resolver)
return this;
}
- public bool TryResolve(string value, Type targetType, out object? resolved)
+ public bool TryResolve(string value, Type targetType, out object? resolved) =>
+ TryResolve(value, targetType, new ResolutionContext(targetType), out resolved);
+
+ public bool TryResolve(string value, Type targetType, ResolutionContext context, out object? resolved)
{
- foreach (IValueResolver resolver in _resolvers)
+ foreach (IValueResolver resolver in _resolvers.Append(_reflectionFallback))
{
- if (!resolver.CanResolve(targetType))
+ if (!resolver.CanResolve(targetType, context))
continue;
try
{
- resolved = resolver.Resolve(value, targetType);
- return resolved != null || !targetType.IsValueType;
+ resolved = resolver.Resolve(value, targetType, context);
+ if (resolved != null || !targetType.IsValueType || Nullable.GetUnderlyingType(targetType) != null)
+ return true;
}
catch
{
- // Try the next compatible resolver. Binding diagnostics are produced by the binder.
+ // Continue through the ordered resolver chain. Binder diagnostics explain failure.
}
}
@@ -58,6 +66,65 @@ public bool TryResolve(string value, out T? resolved)
return false;
}
+ ///
+ /// Resolves repeated syntactic values into an array/list/sequence CLR shape.
+ ///
+ public bool TryResolveMany(IEnumerable values, Type targetType, ResolutionContext context, out object? resolved)
+ {
+ Type? elementType = targetType.IsArray
+ ? targetType.GetElementType()
+ : targetType.GetInterfaces()
+ .Concat(targetType.IsInterface ? [targetType] : [])
+ .FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IEnumerable<>))
+ ?.GetGenericArguments()[0];
+
+ if (elementType == null)
+ {
+ resolved = null;
+ return false;
+ }
+
+ var items = new List();
+ foreach (string value in values)
+ {
+ ResolutionContext elementContext = context with { ExpectedType = elementType };
+ if (!TryResolve(value, elementType, elementContext, out object? item))
+ {
+ resolved = null;
+ return false;
+ }
+ items.Add(item);
+ }
+
+ if (targetType.IsArray)
+ {
+ Array array = Array.CreateInstance(elementType, items.Count);
+ for (int i = 0; i < items.Count; i++) array.SetValue(items[i], i);
+ resolved = array;
+ return true;
+ }
+
+ Type listType = typeof(List<>).MakeGenericType(elementType);
+ IList list = (IList)Activator.CreateInstance(listType)!;
+ foreach (object? item in items) list.Add(item);
+
+ if (targetType.IsAssignableFrom(listType) || targetType.IsInterface)
+ {
+ resolved = list;
+ return true;
+ }
+
+ ConstructorInfo? sequenceConstructor = targetType.GetConstructor([typeof(IEnumerable<>).MakeGenericType(elementType)]);
+ if (sequenceConstructor != null)
+ {
+ resolved = sequenceConstructor.Invoke([list]);
+ return true;
+ }
+
+ resolved = null;
+ return false;
+ }
+
private sealed class StringResolver : ValueResolver
{
protected override string Resolve(string value) => value;
diff --git a/src/FluNet.Engine/Binding/VerbActivator.cs b/src/FluNet.Engine/Binding/VerbActivator.cs
new file mode 100644
index 0000000..669f48d
--- /dev/null
+++ b/src/FluNet.Engine/Binding/VerbActivator.cs
@@ -0,0 +1,43 @@
+using FluNET.Language.Metadata;
+using FluNET.Syntax.Ast;
+using FluNET.Syntax.Core;
+
+namespace FluNET.Binding;
+
+public sealed record ActivationContext(IReadOnlyDictionary? Variables = null, object? PipelineValue = null, IServiceProvider? Services = null);
+
+public sealed class VerbActivator
+{
+ private readonly ExpressionRuntimeEvaluator _expressions = new();
+
+ public IVerb Create(BoundSentence sentence, ActivationContext? context = null)
+ {
+ context ??= new ActivationContext(); ConstructorDescriptor? constructor = sentence.Constructor;
+ if (constructor == null) { IVerb? fallback = sentence.Verb.Factory(); return fallback ?? throw new InvalidOperationException($"Verb '{sentence.Verb.VerbType.FullName}' has no usable constructor or factory."); }
+ var remainingRoles = sentence.Roles.ToList(); object?[] arguments = new object?[constructor.Parameters.Count];
+ for (int i = 0; i < constructor.Parameters.Count; i++)
+ {
+ ParameterDescriptor p = constructor.Parameters[i];
+ if (p.FromServices || p.Role == null)
+ {
+ object? service = context.Services?.GetService(p.ParameterType); if (service != null) { arguments[i] = service; continue; }
+ if (p.Role == null) { if (p.Parameter.HasDefaultValue) { arguments[i] = p.Parameter.DefaultValue; continue; } if (p.IsOptional) { arguments[i] = DefaultValue(p.ParameterType); continue; } throw new InvalidOperationException($"Cannot resolve service parameter '{p.Name}' ({p.ParameterType.Name}) for '{sentence.Verb.Text}'."); }
+ }
+ BoundRole? role = FindRole(p, remainingRoles); if (role == null) { if (p.IsOptional) { arguments[i] = p.Parameter.HasDefaultValue ? p.Parameter.DefaultValue : DefaultValue(p.ParameterType); continue; } throw new InvalidOperationException($"Missing bound role '{p.Role}' for constructor parameter '{p.Name}'."); }
+ remainingRoles.Remove(role); arguments[i] = MaterializeRole(p, role, context);
+ }
+ object instance = constructor.Activator(arguments); return instance as IVerb ?? throw new InvalidOperationException($"Constructed type '{instance.GetType().FullName}' is not an IVerb.");
+ }
+
+ private static BoundRole? FindRole(ParameterDescriptor p, IReadOnlyList roles) { BoundRole? named = roles.FirstOrDefault(x => x.Descriptor.Kind == p.Role && !string.IsNullOrWhiteSpace(x.Descriptor.Name) && x.Descriptor.Name.Equals(p.Name, StringComparison.OrdinalIgnoreCase)); return named ?? roles.FirstOrDefault(x => x.Descriptor.Kind == p.Role); }
+ private object? MaterializeRole(ParameterDescriptor p, BoundRole r, ActivationContext c) { if (r.Values.Count == 0) return DefaultValue(p.ParameterType); if (r.Values.Count == 1) return MaterializeValue(r.Values[0], p.ParameterType, r.Descriptor.Direction, c); if (p.ParameterType.IsArray) { Type e = p.ParameterType.GetElementType()!; Array a = Array.CreateInstance(e, r.Values.Count); for (int i = 0; i < r.Values.Count; i++) a.SetValue(MaterializeValue(r.Values[i], e, r.Descriptor.Direction, c), i); return a; } throw new InvalidOperationException($"Role '{r.Descriptor.Kind}' produced multiple values for non-collection parameter '{p.Name}'."); }
+ private object? MaterializeValue(BoundValue v, Type t, RoleDirection d, ActivationContext c)
+ {
+ object? raw;
+ if (v.ConstantValue != null) raw = v.ConstantValue;
+ else if (v.Source is VariableExpression && d == RoleDirection.Output) raw = DefaultValue(t);
+ else raw = _expressions.Evaluate(v.Source, c);
+ return v.Conversion?.Apply(raw) ?? raw;
+ }
+ private static object? DefaultValue(Type t) { if (t.IsArray) return Array.CreateInstance(t.GetElementType()!, 0); if (t.IsValueType) return Activator.CreateInstance(t); return null; }
+}
diff --git a/src/FluNet.Engine/Compilation/ClassicCompiler.cs b/src/FluNet.Engine/Compilation/ClassicCompiler.cs
new file mode 100644
index 0000000..35053fc
--- /dev/null
+++ b/src/FluNet.Engine/Compilation/ClassicCompiler.cs
@@ -0,0 +1,39 @@
+using FluNET.Binding;
+using FluNET.Diagnostics;
+using FluNET.Language;
+using FluNET.Syntax.Ast;
+using FluNET.Syntax.Parsing;
+
+namespace FluNET.Compilation;
+
+public sealed record ClassicCompilation(ScriptNode? Syntax, IReadOnlyList Pipelines, IReadOnlyList Diagnostics)
+{
+ public bool Success => Syntax != null && Diagnostics.All(x => x.Severity != DiagnosticSeverity.Error);
+}
+
+public sealed class ClassicCompiler
+{
+ private readonly ClassicParser _parser;
+ private readonly SemanticBinder _binder;
+
+ public ClassicCompiler(LanguageSnapshot language, ValueResolverRegistry? resolvers = null, ValueConversionRegistry? conversions = null)
+ {
+ _parser = new ClassicParser(language);
+ _binder = new SemanticBinder(language, resolvers, conversions);
+ }
+
+ public ClassicCompilation Compile(string source, BindingContext? context = null)
+ {
+ ParseResult parse = _parser.Parse(source);
+ var diagnostics = new List(parse.Diagnostics);
+ var pipelines = new List();
+ if (!parse.Success || parse.Script == null) return new(parse.Script, pipelines, diagnostics);
+ foreach (PipelineNode pipeline in parse.Script.Pipelines)
+ {
+ BindingResult binding = _binder.BindPipeline(pipeline, context);
+ diagnostics.AddRange(binding.Diagnostics);
+ if (binding.Value != null) pipelines.Add(binding.Value);
+ }
+ return new(parse.Script, pipelines, diagnostics);
+ }
+}
diff --git a/src/FluNet.Engine/Execution/BoundPipelineExecutor.cs b/src/FluNet.Engine/Execution/BoundPipelineExecutor.cs
new file mode 100644
index 0000000..1c7952e
--- /dev/null
+++ b/src/FluNet.Engine/Execution/BoundPipelineExecutor.cs
@@ -0,0 +1,66 @@
+using FluNET.Binding;
+using FluNET.Execution.Capabilities;
+
+namespace FluNET.Execution;
+
+public sealed record BoundPipelineExecutionResult(
+ object? Result,
+ IReadOnlyDictionary Variables,
+ IReadOnlyList Sentences);
+
+///
+/// Executes a semantically bound pipeline. Values flow through THEN implicitly and output
+/// bindings are projected from each CLR result by name or position.
+///
+public sealed class BoundPipelineExecutor
+{
+ private readonly BoundSentenceExecutor _sentenceExecutor;
+ private readonly ICapabilityPolicy _capabilities;
+ private readonly OutputBindingProjector _outputs;
+
+ public BoundPipelineExecutor(
+ BoundSentenceExecutor? sentenceExecutor = null,
+ ICapabilityPolicy? capabilities = null,
+ OutputBindingProjector? outputs = null)
+ {
+ _sentenceExecutor = sentenceExecutor ?? new BoundSentenceExecutor();
+ _capabilities = capabilities ?? AllowAllCapabilityPolicy.Instance;
+ _outputs = outputs ?? new OutputBindingProjector();
+ }
+
+ public async ValueTask ExecuteAsync(
+ BoundPipeline pipeline,
+ IReadOnlyDictionary? initialVariables = null,
+ IServiceProvider? services = null,
+ CancellationToken cancellationToken = default)
+ {
+ var variables = initialVariables != null
+ ? new Dictionary(initialVariables, StringComparer.OrdinalIgnoreCase)
+ : new Dictionary(StringComparer.OrdinalIgnoreCase);
+ var executions = new List();
+ object? pipelineValue = null;
+
+ foreach (BoundSentence sentence in pipeline.Sentences)
+ {
+ EnsureCapabilities(sentence);
+ var activation = new ActivationContext(variables, pipelineValue, services);
+ BoundExecutionResult execution = await _sentenceExecutor.ExecuteAsync(sentence, activation, cancellationToken);
+ executions.Add(execution);
+ pipelineValue = execution.Result;
+
+ foreach (KeyValuePair binding in _outputs.Project(sentence, execution.Result))
+ variables[binding.Key] = binding.Value;
+ }
+
+ return new(pipelineValue, variables, executions);
+ }
+
+ private void EnsureCapabilities(BoundSentence sentence)
+ {
+ foreach (string capability in sentence.Verb.Capabilities)
+ {
+ if (!_capabilities.IsAllowed(capability, sentence.Verb))
+ throw new CapabilityDeniedException(capability, sentence.Verb);
+ }
+ }
+}
diff --git a/src/FluNet.Engine/Execution/BoundSentenceExecutor.cs b/src/FluNet.Engine/Execution/BoundSentenceExecutor.cs
new file mode 100644
index 0000000..52f81fa
--- /dev/null
+++ b/src/FluNet.Engine/Execution/BoundSentenceExecutor.cs
@@ -0,0 +1,43 @@
+using FluNET.Binding;
+using FluNET.Syntax.Core;
+using System.Reflection;
+
+namespace FluNET.Execution;
+
+public sealed record BoundExecutionResult(IVerb Verb, object? Result);
+
+///
+/// Transitional executor for the new bound model. New async verbs use IAsyncVerb;
+/// legacy Classic verbs continue to execute through their parameterless Invoke method.
+///
+public sealed class BoundSentenceExecutor
+{
+ private readonly VerbActivator _activator = new();
+
+ public async ValueTask ExecuteAsync(
+ BoundSentence sentence,
+ ActivationContext? context = null,
+ CancellationToken cancellationToken = default)
+ {
+ IVerb verb = _activator.Create(sentence, context);
+
+ if (verb is IAsyncVerb asyncVerb)
+ {
+ object? asyncResult = await asyncVerb.InvokeAsync(cancellationToken);
+ return new BoundExecutionResult(verb, asyncResult);
+ }
+
+ MethodInfo? invoke = verb.GetType().GetMethod(
+ "Invoke",
+ BindingFlags.Public | BindingFlags.Instance,
+ binder: null,
+ types: Type.EmptyTypes,
+ modifiers: null);
+
+ if (invoke == null)
+ throw new InvalidOperationException($"Verb '{verb.GetType().FullName}' does not expose Invoke() or IAsyncVerb.");
+
+ object? result = invoke.Invoke(verb, null);
+ return new BoundExecutionResult(verb, result);
+ }
+}
diff --git a/src/FluNet.Engine/Execution/Capabilities/ICapabilityPolicy.cs b/src/FluNet.Engine/Execution/Capabilities/ICapabilityPolicy.cs
new file mode 100644
index 0000000..e2280a3
--- /dev/null
+++ b/src/FluNet.Engine/Execution/Capabilities/ICapabilityPolicy.cs
@@ -0,0 +1,27 @@
+using FluNET.Language;
+
+namespace FluNET.Execution.Capabilities;
+
+public interface ICapabilityPolicy
+{
+ bool IsAllowed(string capability, VerbDescriptor verb);
+}
+
+public sealed class AllowAllCapabilityPolicy : ICapabilityPolicy
+{
+ public static AllowAllCapabilityPolicy Instance { get; } = new();
+ public bool IsAllowed(string capability, VerbDescriptor verb) => true;
+}
+
+public sealed class ExplicitCapabilityPolicy(IEnumerable allowed) : ICapabilityPolicy
+{
+ private readonly HashSet _allowed = new(allowed, StringComparer.OrdinalIgnoreCase);
+ public bool IsAllowed(string capability, VerbDescriptor verb) => _allowed.Contains(capability);
+}
+
+public sealed class CapabilityDeniedException(string capability, VerbDescriptor verb)
+ : InvalidOperationException($"Capability '{capability}' required by '{verb.Text}' is not allowed.")
+{
+ public string Capability { get; } = capability;
+ public VerbDescriptor Verb { get; } = verb;
+}
diff --git a/src/FluNet.Engine/Execution/ClassicScriptEngine.cs b/src/FluNet.Engine/Execution/ClassicScriptEngine.cs
new file mode 100644
index 0000000..a8d4c39
--- /dev/null
+++ b/src/FluNet.Engine/Execution/ClassicScriptEngine.cs
@@ -0,0 +1,70 @@
+using FluNET.Binding;
+using FluNET.Compilation;
+using FluNET.Diagnostics;
+using FluNET.Execution.Capabilities;
+using FluNET.Language;
+
+namespace FluNET.Execution;
+
+public sealed record ClassicScriptResult(
+ ClassicCompilation Compilation,
+ IReadOnlyList Executions,
+ IReadOnlyDictionary Variables)
+{
+ public bool Success => Compilation.Success;
+ public object? Result => Executions.LastOrDefault()?.Result;
+}
+
+///
+/// New opt-in FluNET.Classic execution path. It does not replace the legacy Engine yet;
+/// it proves source -> AST -> binding -> capability check -> execution as one coherent API.
+///
+public sealed class ClassicScriptEngine
+{
+ private readonly ClassicCompiler _compiler;
+ private readonly BoundPipelineExecutor _executor;
+ private readonly IServiceProvider? _services;
+
+ public ClassicScriptEngine(
+ LanguageSnapshot language,
+ IServiceProvider? services = null,
+ ValueResolverRegistry? resolvers = null,
+ ValueConversionRegistry? conversions = null,
+ ICapabilityPolicy? capabilities = null)
+ {
+ _compiler = new ClassicCompiler(language, resolvers, conversions);
+ _executor = new BoundPipelineExecutor(capabilities: capabilities);
+ _services = services;
+ }
+
+ public async ValueTask RunAsync(
+ string source,
+ IReadOnlyDictionary? variables = null,
+ CancellationToken cancellationToken = default)
+ {
+ var typeMap = variables?.Where(x => x.Value != null)
+ .ToDictionary(x => x.Key, x => x.Value!.GetType(), StringComparer.OrdinalIgnoreCase);
+ ClassicCompilation compilation = _compiler.Compile(source, new BindingContext(typeMap, Services: _services));
+ if (!compilation.Success)
+ return new(compilation, [], variables ?? new Dictionary());
+
+ var runtimeVariables = variables != null
+ ? new Dictionary(variables, StringComparer.OrdinalIgnoreCase)
+ : new Dictionary(StringComparer.OrdinalIgnoreCase);
+ var executions = new List();
+
+ foreach (BoundPipeline pipeline in compilation.Pipelines)
+ {
+ BoundPipelineExecutionResult execution = await _executor.ExecuteAsync(
+ pipeline,
+ runtimeVariables,
+ _services,
+ cancellationToken);
+ executions.Add(execution);
+ foreach (KeyValuePair pair in execution.Variables)
+ runtimeVariables[pair.Key] = pair.Value;
+ }
+
+ return new(compilation, executions, runtimeVariables);
+ }
+}
diff --git a/src/FluNet.Engine/Execution/OutputBindingProjector.cs b/src/FluNet.Engine/Execution/OutputBindingProjector.cs
new file mode 100644
index 0000000..8dbfee0
--- /dev/null
+++ b/src/FluNet.Engine/Execution/OutputBindingProjector.cs
@@ -0,0 +1,104 @@
+using FluNET.Binding;
+using FluNET.Syntax.Ast;
+using FluNET.Syntax.Core;
+using System.Collections;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace FluNET.Execution;
+
+///
+/// Projects a single CLR result into one or many output WHAT bindings. Named slots prefer
+/// dictionary/property metadata; positional tuples/lists are used as a fallback.
+///
+public sealed class OutputBindingProjector
+{
+ public IReadOnlyDictionary Project(BoundSentence sentence, object? result)
+ {
+ var bindings = sentence.Roles
+ .Where(x => x.Descriptor.Direction is RoleDirection.Output or RoleDirection.InputOutput)
+ .SelectMany(role => role.Values
+ .Where(value => value.Source is VariableExpression)
+ .Select(value => new OutputSlot(
+ ((VariableExpression)value.Source).Name,
+ role.Descriptor.Name)))
+ .ToArray();
+
+ if (bindings.Length == 0)
+ return new Dictionary();
+
+ if (bindings.Length == 1)
+ return new Dictionary(StringComparer.OrdinalIgnoreCase)
+ {
+ [bindings[0].VariableName] = result
+ };
+
+ var projected = new Dictionary(StringComparer.OrdinalIgnoreCase);
+ if (TryProjectDictionary(result, bindings, projected)) return projected;
+ if (TryProjectProperties(result, bindings, projected)) return projected;
+ if (TryProjectTuple(result, bindings, projected)) return projected;
+ if (TryProjectList(result, bindings, projected)) return projected;
+
+ throw new InvalidOperationException(
+ $"Verb '{sentence.Verb.Text}' returned '{result?.GetType().FullName ?? "null"}' for {bindings.Length} output bindings, but the result cannot be projected by name or position.");
+ }
+
+ private static bool TryProjectDictionary(object? result, OutputSlot[] slots, IDictionary output)
+ {
+ if (result is IReadOnlyDictionary readOnly)
+ {
+ foreach (OutputSlot slot in slots)
+ {
+ string key = slot.SlotName ?? slot.VariableName;
+ KeyValuePair match = readOnly.FirstOrDefault(x => x.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+ if (match.Key == null) { output.Clear(); return false; }
+ output[slot.VariableName] = match.Value;
+ }
+ return true;
+ }
+
+ if (result is IDictionary dictionary)
+ {
+ foreach (OutputSlot slot in slots)
+ {
+ string key = slot.SlotName ?? slot.VariableName;
+ object? foundKey = dictionary.Keys.Cast().FirstOrDefault(x => x?.ToString()?.Equals(key, StringComparison.OrdinalIgnoreCase) == true);
+ if (foundKey == null) { output.Clear(); return false; }
+ output[slot.VariableName] = dictionary[foundKey];
+ }
+ return true;
+ }
+
+ return false;
+ }
+
+ private static bool TryProjectProperties(object? result, OutputSlot[] slots, IDictionary output)
+ {
+ if (result == null) return false;
+ PropertyInfo[] properties = result.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
+ foreach (OutputSlot slot in slots)
+ {
+ string name = slot.SlotName ?? slot.VariableName;
+ PropertyInfo? property = properties.FirstOrDefault(x => x.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
+ if (property == null) { output.Clear(); return false; }
+ output[slot.VariableName] = property.GetValue(result);
+ }
+ return true;
+ }
+
+ private static bool TryProjectTuple(object? result, OutputSlot[] slots, IDictionary output)
+ {
+ if (result is not ITuple tuple || tuple.Length != slots.Length) return false;
+ for (int i = 0; i < slots.Length; i++) output[slots[i].VariableName] = tuple[i];
+ return true;
+ }
+
+ private static bool TryProjectList(object? result, OutputSlot[] slots, IDictionary output)
+ {
+ if (result is not IList list || list.Count != slots.Length) return false;
+ for (int i = 0; i < slots.Length; i++) output[slots[i].VariableName] = list[i];
+ return true;
+ }
+
+ private sealed record OutputSlot(string VariableName, string? SlotName);
+}
diff --git a/src/FluNet.Engine/Language/ConstructorActivatorCompiler.cs b/src/FluNet.Engine/Language/ConstructorActivatorCompiler.cs
new file mode 100644
index 0000000..1dd5bcc
--- /dev/null
+++ b/src/FluNet.Engine/Language/ConstructorActivatorCompiler.cs
@@ -0,0 +1,24 @@
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace FluNET.Language;
+
+internal static class ConstructorActivatorCompiler
+{
+ public static Func Compile(ConstructorInfo constructor)
+ {
+ ParameterExpression arguments = Expression.Parameter(typeof(object[]), "arguments");
+ ParameterInfo[] parameters = constructor.GetParameters();
+ Expression[] converted = new Expression[parameters.Length];
+
+ for (int i = 0; i < parameters.Length; i++)
+ {
+ BinaryExpression index = Expression.ArrayIndex(arguments, Expression.Constant(i));
+ converted[i] = Expression.Convert(index, parameters[i].ParameterType);
+ }
+
+ NewExpression create = Expression.New(constructor, converted);
+ UnaryExpression box = Expression.Convert(create, typeof(object));
+ return Expression.Lambda>(box, arguments).Compile();
+ }
+}
diff --git a/src/FluNet.Engine/Language/IFluNetModule.cs b/src/FluNet.Engine/Language/IFluNetModule.cs
index 640680f..8a20d46 100644
--- a/src/FluNet.Engine/Language/IFluNetModule.cs
+++ b/src/FluNet.Engine/Language/IFluNetModule.cs
@@ -1,11 +1,13 @@
namespace FluNET.Language;
///
-/// Extension boundary for language packages such as FluNET.Http, FluNET.Sql or FluNET.Json.
-/// Modules enrich vocabulary without modifying the core engine.
+/// Extension boundary for language packages such as FluNET.Classic.Http or FluNET.Classic.Sql.
///
public interface IFluNetModule
{
+ string Name => GetType().Assembly.GetName().Name ?? GetType().Name;
+ Version Version => GetType().Assembly.GetName().Version ?? new Version(0, 1, 0);
+ IReadOnlyCollection Dependencies => Array.Empty();
void Configure(LanguageRegistry language);
}
@@ -14,8 +16,7 @@ public static class LanguageRegistryModuleExtensions
public static LanguageRegistry AddModule(this LanguageRegistry language)
where TModule : IFluNetModule, new()
{
- new TModule().Configure(language);
- language.RegisterAssemblies(new[] { typeof(TModule).Assembly });
+ language.RegisterModule(new TModule());
return language;
}
}
diff --git a/src/FluNet.Engine/Language/ILanguageElement.cs b/src/FluNet.Engine/Language/ILanguageElement.cs
new file mode 100644
index 0000000..d9d04ec
--- /dev/null
+++ b/src/FluNet.Engine/Language/ILanguageElement.cs
@@ -0,0 +1,11 @@
+namespace FluNET.Language;
+
+///
+/// Common identity contract for elements that become part of the compiled FluNET language.
+/// Stable identifiers are intended for diagnostics, manifests, tooling and caches.
+///
+public interface ILanguageElement
+{
+ string StableId { get; }
+ string Name { get; }
+}
diff --git a/src/FluNet.Engine/Language/LanguageBuildResult.cs b/src/FluNet.Engine/Language/LanguageBuildResult.cs
new file mode 100644
index 0000000..9b52f82
--- /dev/null
+++ b/src/FluNet.Engine/Language/LanguageBuildResult.cs
@@ -0,0 +1,10 @@
+using FluNET.Diagnostics;
+
+namespace FluNET.Language;
+
+public sealed record LanguageBuildResult(
+ LanguageSnapshot Snapshot,
+ IReadOnlyList Diagnostics)
+{
+ public bool Success => Diagnostics.All(x => x.Severity != DiagnosticSeverity.Error);
+}
diff --git a/src/FluNet.Engine/Language/LanguageCompiler.cs b/src/FluNet.Engine/Language/LanguageCompiler.cs
new file mode 100644
index 0000000..2f47062
--- /dev/null
+++ b/src/FluNet.Engine/Language/LanguageCompiler.cs
@@ -0,0 +1,221 @@
+using FluNET.Language.Metadata;
+using FluNET.Syntax.Core;
+using FluNET.Syntax.Nouns;
+using System.Reflection;
+
+namespace FluNET.Language;
+
+public sealed class LanguageCompiler
+{
+ private readonly NullabilityInfoContext _nullability = new();
+
+ public VerbIdentity? DescribeVerbIdentity(Type verbType, IVerb? prototype = null)
+ {
+ VerbAttribute? explicitVerb = verbType.GetCustomAttribute(true);
+ string? text = explicitVerb?.Text ?? InferFamilyKeyword(verbType) ?? prototype?.Text;
+ if (string.IsNullOrWhiteSpace(text)) return null;
+ string[] synonyms = verbType.GetCustomAttributes(true)
+ .Select(x => x.Value)
+ .Concat(prototype?.Synonyms ?? [])
+ .Where(x => !string.IsNullOrWhiteSpace(x))
+ .Distinct(StringComparer.OrdinalIgnoreCase)
+ .ToArray();
+ return new VerbIdentity(text.ToUpperInvariant(), synonyms);
+ }
+
+ public VerbDescriptor DescribeVerb(Type verbType, string text, IReadOnlyList synonyms, Func factory)
+ {
+ IReadOnlyList constructors = DescribeConstructors(verbType);
+ IReadOnlyList patterns = BuildPatterns(verbType, text, constructors);
+ SentencePattern compatibilityPattern = patterns.FirstOrDefault()?.Pattern ?? BuildInterfacePattern(verbType, text);
+ string[] explicitCapabilities = verbType.GetCustomAttributes(true)
+ .Select(x => x.Capability)
+ .Distinct(StringComparer.OrdinalIgnoreCase)
+ .ToArray();
+
+ return new VerbDescriptor(verbType, text, synonyms, compatibilityPattern, factory)
+ {
+ Constructors = constructors,
+ Patterns = patterns,
+ ResultType = InferResultType(verbType),
+ FamilyType = InferFamilyType(verbType),
+ Capabilities = MetadataConventionInference.InferCapabilities(text, patterns, explicitCapabilities, verbType),
+ Traits = MetadataConventionInference.InferTraits(text, verbType)
+ };
+ }
+
+ public IReadOnlyList DescribeConstructors(Type type) =>
+ type.GetConstructors(BindingFlags.Public | BindingFlags.Instance)
+ .Select(c => new ConstructorDescriptor(
+ c,
+ c.GetParameters().Select(p => DescribeParameter(type, p)).ToArray(),
+ ConstructorActivatorCompiler.Compile(c)))
+ .OrderByDescending(x => x.RoleParameterCount)
+ .ThenBy(x => x.ServiceParameterCount)
+ .ToArray();
+
+ private IReadOnlyList BuildPatterns(Type verbType, string text, IReadOnlyList constructors)
+ {
+ var patterns = new List();
+ foreach (ConstructorDescriptor constructor in constructors.Where(x => x.RoleParameterCount > 0))
+ {
+ ClauseDescriptor[] clauses = constructor.Parameters.Where(x => x.Role != null).Select(ToClause).ToArray();
+ if (clauses.Length > 0) patterns.Add(new(new SentencePattern(text.ToUpperInvariant(), clauses), constructor));
+ }
+
+ if (patterns.Count == 0)
+ patterns.Add(new(BuildInterfacePattern(verbType, text), constructors.FirstOrDefault()));
+
+ return patterns.DistinctBy(x => PatternKey(x.Pattern), StringComparer.OrdinalIgnoreCase).ToArray();
+ }
+
+ private static string PatternKey(SentencePattern pattern) => string.Join("|", pattern.Clauses.Select(x =>
+ $"{x.Kind}:{x.Name}:{x.ValueType.FullName}:{x.Cardinality}:{x.Direction}"));
+
+ private static ClauseDescriptor ToClause(ParameterDescriptor p) => new(
+ p.Role!.Value,
+ p.ParameterType,
+ !p.IsOptional,
+ p.Name,
+ p.Direction,
+ p.IsParams ? RoleCardinality.ZeroOrMore : (p.IsOptional ? RoleCardinality.ZeroOrOne : RoleCardinality.One),
+ p.Shape.ElementType);
+
+ private SentencePattern BuildInterfacePattern(Type verbType, string text)
+ {
+ var fallback = new List();
+ foreach (Type contract in verbType.GetInterfaces().Where(x => x.IsGenericType))
+ {
+ Type definition = contract.GetGenericTypeDefinition();
+ Type valueType = contract.GetGenericArguments()[0];
+ ClauseKind? kind = RoleKindFor(definition);
+ if (kind == null) continue;
+ TypeShape shape = TypeShape.Analyze(valueType);
+ RoleDirection direction = kind == ClauseKind.What && IsFamily(verbType, typeof(IGet), "Get")
+ ? RoleDirection.Output
+ : RoleDirection.Input;
+ fallback.Add(new(kind.Value, valueType, true, null, direction, RoleCardinality.One, shape.ElementType));
+ }
+ return new SentencePattern(text.ToUpperInvariant(), fallback);
+ }
+
+ private ParameterDescriptor DescribeParameter(Type verbType, ParameterInfo p)
+ {
+ ClauseKind? role = InferRole(p);
+ NullabilityInfo n = _nullability.Create(p);
+ bool isParams = p.GetCustomAttribute() != null;
+ bool optional = p.IsOptional || p.HasDefaultValue || p.GetCustomAttribute() != null || n.ReadState == NullabilityState.Nullable;
+ return new(
+ p,
+ p.Name ?? $"arg{p.Position}",
+ p.ParameterType,
+ role,
+ InferDirection(verbType, p, role),
+ optional,
+ isParams,
+ p.GetCustomAttribute() != null,
+ n.ReadState,
+ n.WriteState,
+ TypeShape.Analyze(p.ParameterType));
+ }
+
+ private static ClauseKind? InferRole(ParameterInfo p)
+ {
+ RoleAttribute? a = p.GetCustomAttribute();
+ if (a != null) return a.Kind;
+ return p.Name?.ToLowerInvariant() switch
+ {
+ "what" => ClauseKind.What,
+ "from" => ClauseKind.From,
+ "to" => ClauseKind.To,
+ "using" => ClauseKind.Using,
+ "with" => ClauseKind.With,
+ "then" => ClauseKind.Then,
+ _ => null
+ };
+ }
+
+ private static RoleDirection InferDirection(Type t, ParameterInfo p, ClauseKind? r)
+ {
+ if (p.GetCustomAttribute() != null) return RoleDirection.Output;
+ if (p.GetCustomAttribute() != null) return RoleDirection.InputOutput;
+ if (p.GetCustomAttribute() != null) return RoleDirection.Input;
+ return r == ClauseKind.What && IsFamily(t, typeof(IGet), "Get") ? RoleDirection.Output : RoleDirection.Input;
+ }
+
+ private static ClauseKind? RoleKindFor(Type d) =>
+ d == typeof(IWhat<>) ? ClauseKind.What :
+ d == typeof(IFrom<>) ? ClauseKind.From :
+ d == typeof(ITo<>) ? ClauseKind.To :
+ d == typeof(IUsing<>) ? ClauseKind.Using :
+ d == typeof(IWith<>) ? ClauseKind.With :
+ d == typeof(IThen<>) ? ClauseKind.Then : null;
+
+ private static Type? InferResultType(Type t) =>
+ t.GetInterfaces().FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IVerb<>))?.GetGenericArguments()[0];
+
+ private static Type? InferFamilyType(Type t)
+ {
+ Type[] families = [typeof(IGet), typeof(ISave), typeof(ILoad), typeof(ISend), typeof(IDelete), typeof(IDownload), typeof(IPost), typeof(ITransform), typeof(ISay)];
+ Type? marker = families.FirstOrDefault(x => x.IsAssignableFrom(t));
+ if (marker != null) return marker;
+ Type? current = t.BaseType;
+ while (current != null && current != typeof(object))
+ {
+ Type candidate = current.IsGenericType ? current.GetGenericTypeDefinition() : current;
+ if (KnownFamilyKeyword(candidate.Name) != null) return candidate;
+ current = current.BaseType;
+ }
+ return null;
+ }
+
+ private static string? InferFamilyKeyword(Type t)
+ {
+ if (typeof(IGet).IsAssignableFrom(t)) return "GET";
+ if (typeof(ISave).IsAssignableFrom(t)) return "SAVE";
+ if (typeof(ILoad).IsAssignableFrom(t)) return "LOAD";
+ if (typeof(ISend).IsAssignableFrom(t)) return "SEND";
+ if (typeof(IDelete).IsAssignableFrom(t)) return "DELETE";
+ if (typeof(IDownload).IsAssignableFrom(t)) return "DOWNLOAD";
+ if (typeof(IPost).IsAssignableFrom(t)) return "POST";
+ if (typeof(ITransform).IsAssignableFrom(t)) return "TRANSFORM";
+ if (typeof(ISay).IsAssignableFrom(t)) return "SAY";
+
+ Type? current = t.BaseType;
+ while (current != null && current != typeof(object))
+ {
+ Type candidate = current.IsGenericType ? current.GetGenericTypeDefinition() : current;
+ string? keyword = KnownFamilyKeyword(candidate.Name);
+ if (keyword != null) return keyword;
+ current = current.BaseType;
+ }
+ return null;
+ }
+
+ private static string? KnownFamilyKeyword(string n) => n.Split('`')[0].ToUpperInvariant() switch
+ {
+ "GET" => "GET",
+ "SAVE" => "SAVE",
+ "LOAD" => "LOAD",
+ "SEND" => "SEND",
+ "DELETE" => "DELETE",
+ "DOWNLOAD" => "DOWNLOAD",
+ "POST" => "POST",
+ "TRANSFORM" => "TRANSFORM",
+ "SAY" => "SAY",
+ _ => null
+ };
+
+ private static bool IsFamily(Type t, Type marker, string legacy)
+ {
+ if (marker.IsAssignableFrom(t)) return true;
+ Type? current = t.BaseType;
+ while (current != null && current != typeof(object))
+ {
+ Type candidate = current.IsGenericType ? current.GetGenericTypeDefinition() : current;
+ if (candidate.Name.Split('`')[0].Equals(legacy, StringComparison.OrdinalIgnoreCase)) return true;
+ current = current.BaseType;
+ }
+ return false;
+ }
+}
diff --git a/src/FluNet.Engine/Language/LanguageDescriptors.cs b/src/FluNet.Engine/Language/LanguageDescriptors.cs
new file mode 100644
index 0000000..1b7d6bb
--- /dev/null
+++ b/src/FluNet.Engine/Language/LanguageDescriptors.cs
@@ -0,0 +1,48 @@
+using FluNET.Language.Metadata;
+using FluNET.Syntax.Core;
+
+namespace FluNET.Language;
+
+public sealed record VerbIdentity(string Text, IReadOnlyList Synonyms);
+
+public sealed record ExecutionTraitsDescriptor(
+ bool Pure,
+ bool Idempotent,
+ bool Retryable,
+ bool Transactional,
+ bool LongRunning,
+ bool SideEffecting);
+
+public sealed record VerbPatternDescriptor(
+ SentencePattern Pattern,
+ ConstructorDescriptor? Constructor);
+
+public sealed record WordDescriptor(Type WordType, string Text, IReadOnlyList Synonyms, Func Factory) : ILanguageElement
+{
+ public string StableId => $"word:{Text.ToLowerInvariant()}:{WordType.FullName}";
+ public string Name => Text;
+}
+
+public sealed record VerbDescriptor(Type VerbType, string Text, IReadOnlyList Synonyms, SentencePattern Pattern, Func Factory) : ILanguageElement
+{
+ public string StableId => $"verb:{Text.ToLowerInvariant()}:{VerbType.FullName}";
+ public string Name => Text;
+ public IReadOnlyList Constructors { get; init; } = [];
+ public IReadOnlyList Patterns { get; init; } = [];
+ public Type? ResultType { get; init; }
+ public Type? FamilyType { get; init; }
+ public IReadOnlyList Capabilities { get; init; } = [];
+ public ExecutionTraitsDescriptor Traits { get; init; } = new(false, false, false, false, false, false);
+}
+
+public sealed record QualifierDescriptor(string Text, Type? ValueType = null) : ILanguageElement
+{
+ public string StableId => $"qualifier:{Text.ToLowerInvariant()}";
+ public string Name => Text;
+}
+
+public sealed record ModuleDescriptor(string ModuleName, Version Version, Type ModuleType, IReadOnlyList Dependencies) : ILanguageElement
+{
+ public string StableId => $"module:{ModuleName.ToLowerInvariant()}";
+ public string Name => ModuleName;
+}
diff --git a/src/FluNet.Engine/Language/LanguageIntrospection.cs b/src/FluNet.Engine/Language/LanguageIntrospection.cs
new file mode 100644
index 0000000..96f578e
--- /dev/null
+++ b/src/FluNet.Engine/Language/LanguageIntrospection.cs
@@ -0,0 +1,52 @@
+using System.Text.Json;
+
+namespace FluNET.Language;
+
+public sealed record LanguageManifest(IReadOnlyList