d4rt 0.2.6

An interpreter and runtime for the Dart language. It allows you to execute Dart code dynamically in your Dart/Flutter applications

0.2.6

• Downgrade build and build_runner dependencies for compatibility

0.2.5

• security: Hardened sandbox enforcement
  • Permissions now implement value equality, so equivalent permissions can be checked and revoked reliably. Scoped filesystem permissions are canonicalized to prevent symlink escapes. Scoped network and process permissions fail closed when host, port, command or arguments are missing. Isolate spawning and communication enforce their respective capabilities at runtime. Isolate.spawnUri also requires DangerousPermission.codeEvaluation because it executes native Dart code outside the interpreter sandbox.
  • Added permission checks to HTTP, socket, DNS, server bind and UDP send operations. Scoped network permissions disable transparent HTTP redirects, and explicit redirect destinations and HTTP proxy endpoints are checked before use. Process.run/start/runSync now enforce command and argument scopes instead of only checking for a generic process permission. Native process execution and signal watching additionally require DangerousPermission.processExecution, because child processes run outside D4rt's filesystem and network sandbox. runInShell: true requires unrestricted ProcessRunPermission.any, since shell parsing can bypass a command/argument scope. Directory listings, watch events, temporary-directory prefixes and link resolution also validate every emitted, created or resolved path, and link creation checks its target, preventing symlink escapes and path traversal.
  • Added descriptor-based filesystem isolation on POSIX systems. File content reads and writes, open streams, copies, create/delete/rename operations, recursive directory deletes, temporary-directory creation and symbolic-link target reads now walk parent components with openat and O_NOFOLLOW, so a symlink substituted after the permission check fails closed instead of redirecting the operation. Temporary directories use mkdirat with mode 0700, while link targets are read with readlinkat and revalidated. FileStat.stat/statSync now enforce filesystem read permissions, and file, directory and link stat operations plus file/directory existence checks use descriptor-backed metadata as well. resolveSymbolicLinks results are checked against the active scope before being returned. Windows and the remaining path-based link-existence, type, directory-listing and watch operations retain the documented TOCTOU limitation.
  • D4rt.eval() now requires DangerousPermission.codeEvaluation.
  • Importing dart:developer now requires DangerousPermission.developerTools; every developer bridge operation, including timeline, tag, flow and VM-service APIs, is checked again at runtime so it remains protected after permission changes.
  • D4rt.analyze() no longer evaluates top-level variable initializers, including initializers from imported modules.
  • Missing modules are rejected even when other bridges are registered, and module initialization now honors timeout and maxSteps. Standard library permission checks use the parsed library name, so URI query strings or fragments cannot bypass dart:io, dart:isolate or dart:developer restrictions.
  • The CLI is deny-by-default and exposes --allow-fs, --allow-network, --allow-process, --allow-isolate, --allow-dangerous and --allow-all. --allow-process also grants DangerousPermission.processExecution. Scripts get read-only access to their own directory by default.
  • Updated to analyzer 14.5.0, build 5.0.0, source_gen 4.3.1, build_runner 2.17.1 and test 1.33.0, with a Dart SDK constraint of ^3.11.0.
• perf: Reduce interpreter overhead in hot paths
  • Added direct numeric, string and boolean binary/compound-assignment fast paths, avoided redundant environment and bridge lookups, and reused block environments when a block cannot introduce bindings.
  • Debug logging is now guarded by Logger.debugEnabled throughout the interpreter, runtime types and loaders, so interpolation and allocation are skipped when debug logging is disabled.
  • These changes reduce the local loop, recursion, method-call, string and collection microbenchmark suite from roughly 2.1 s to 0.33 s while keeping the full test suite green.

0.2.4

• feat: Enhance enum handling with improved equality checks and add comprehensive switch statement tests

0.2.3

• feat: Dart 3.0+ Pattern Matching, Relational/Logical Patterns, for-in & if-case Collection Elements
  • Added support for RelationalPattern (> 0, < 100, >= 18, <= 65, == 'admin', != null) in switch expressions, switch statements, and if-case.
  • Added support for LogicalAndPattern (>= 0 && <= 100) with cumulative variable binding.
  • Added support for ParenthesizedPattern ((pattern)), NullCheckPattern (pattern?), NullAssertPattern (pattern!), and CastPattern (pattern as Type).
  • Added for-in pattern destructuring loops (for (final (x, y) in points) and await for (final (x, y) in stream)).
  • Added for-in pattern elements ([for (final (k, v) in map.entries) '$k=$v']) and if-case elements ([if (user case (var name, var age) when age >= 18) name]) in List, Set, and Map collection literals.
  • Added guard clauses (when clause) in SwitchPatternCase for switch statements.
• feat: Closures, Capability & Stream Subtyping (dart:isolate)
  • Added subtyping bridges across Capability, SendPort (sp is Capability), ReceivePort (rp is Stream), Isolate, RawReceivePort, RemoteError (err is Error), and TransferableTypedData.
  • Added support for all callable and closure types (InterpretedFunction, Callable, native Function) in Isolate.run, ReceivePort.listen, and RawReceivePort handlers.
  • Reordered isolate bridge definitions ensuring SendPort and ReceivePort take precedence over abstract Capability.
• feat: Flow Bridge, ServiceProtocolInfo, Service Constants & Closures (dart:developer)
  • Added FlowDeveloper bridge with Flow.begin(), Flow.step(id), Flow.end(id), and flow.id.
  • Added ServiceProtocolInfoDeveloper bridge exposing serverUri and serverWebSocketUri.
  • Added staticGetters for standard error code constants on ServiceExtensionResponse (invalidParams, extensionError, extensionErrorMin, extensionErrorMax).
  • Added support for all callable and closure types (InterpretedFunction, Callable, native Function) in Timeline.timeSync and registerExtension.
• feat: HtmlEscapeMode Static Getters, JsonUnsupportedObjectError & Codec Subtyping (dart:convert)
  • Added staticGetters on HtmlEscapeMode (attribute, element, sqAttribute, unknown) and instance mode properties (escapeQuot, escapeApos, escapeLtGt, escapeSlash).
  • Added JsonUnsupportedObjectErrorConvert bridge with cause, partialResult, unsupportedObject, and isSubtypeOfFunc.
  • Added robust closure and BridgedInstance unwrapping for toEncodable in JsonCodec.encode, JsonEncoder.convert, and global jsonEncode.
  • Added subtyping bridges across Codec, Converter, Encoding, JsonCodec, Utf8Codec, AsciiCodec, Latin1Codec, Base64Codec, HtmlEscape, and LineSplitter.
• feat: Link Bridge, HttpStatus & FileSystemEntity Subtyping (dart:io)
  • Added LinkIo bridge in dart:io supporting symbolic link management (create, target, update, resolveSymbolicLinks, rename, delete, exists, stat) with permission checks.
  • Added HttpStatusIo bridge in dart:io containing all standard HTTP status code constants (HttpStatus.ok, HttpStatus.notFound, etc.).
  • Added unified FileSystemEntity subtyping and optimized bridge lookup ordering for File, Directory, and Link.
• feat: dart:async Reliability, unawaited & Subtyping
  • Fixed argument resolution in Timer.run callback invocation.
  • Added global top-level function unawaited(Future<void> future) in dart:async.
  • Added isSubtypeOfFunc subtyping bridges on Future, Stream, StreamSubscription, StreamTransformer, StreamIterator, StreamController, Timer, and TimeoutException.
• feat: HasNextIterator, Queue .of() Constructors & Subtyping (dart:collection)
  • Added HasNextIteratorCollection bridge supporting HasNextIterator(iterator), hasNext getter, and next() method.
  • Added .of(elements) factory constructors to QueueCollection, ListQueueCollection, and DoubleLinkedQueueCollection.
  • Added DoubleLinkedQueueEntryCollection bridge with append, prepend, remove, previousEntry, and nextEntry.
  • Added isSubtypeOfFunc subtyping bridges across Queue, ListQueue, DoubleLinkedQueue, HashMap, LinkedHashMap, SplayTreeMap, HashSet, LinkedHashSet, SplayTreeSet, LinkedList, LinkedListEntry, UnmodifiableListView, UnmodifiableMapView, and UnmodifiableSetView.
  • Added LinkedHashSetCollection bridge in dart:collection with LinkedHashSet(), LinkedHashSet.from(), LinkedHashSet.of(), and LinkedHashSet.identity().
  • Added built-in Set type check support in visitIsExpression for both native and bridged sets (set is Set).
• feat: Geometry & Operators Bridge (Rectangle.fromPoints, Point operators in dart:math)
  • Added Rectangle.fromPoints(Point a, Point b) in dart:math.
  • Added binary operator dispatch (+, -, *, etc.) for bridged instances in expressions.
  • Added robust unwrapping and isSubtypeOfFunc on Point, Rectangle, and MutableRectangle.
• feat: TypedData Supertype Bridge & Polymorphism (dart:typed_data)
  • Added TypedDataBaseTypedData bridge in dart:typed_data enabling data is TypedData type checks and direct property access (buffer, lengthInBytes, offsetInBytes, elementSizeInBytes).
  • Improved isSubtypeOf resolution across all bridged classes when unwrapping BridgedInstance values.
• feat: Advanced JSON Support & Automatic toJson() Serialization (dart:convert)
  • Added JsonEncoder.withIndent(indent, [toEncodable]) for pretty-printing JSON in interpreted code.
  • Added automatic serialization of interpreted class instances defining toJson() in jsonEncode(...) and JsonEncoder.
  • Added full closure compatibility for toEncodable and reviver callbacks.
• feat: Record Supertype Bridge (Record)
  • Added RecordCore bridge in dart:core allowing rec is Record type checks and record inspection.
• feat: Collection View Bridge (MapView)
  • Added MapViewCollection in dart:collection for wrapping and delegating map operations.
• feat: Hashing Utilities (Object.hash, Object.hashAll, Object.hashAllUnordered)
  • Added modern Dart hashing utilities in dart:core for custom object hashing and composite key creation.
• feat: Microtask Scheduling & Zones (scheduleMicrotask & Zone)
  • Added scheduleMicrotask(void Function() callback) in dart:async.
  • Added full bridge for Zone (Zone.current, Zone.root, zone.run(...), zone.runGuarded(...), zone.inSameErrorZone(...), zone[key]).
• feat: Enhanced CLI Tooling (bin/d4rt.dart)
  • Added --eval / -e "<code>" flag to evaluate inline Dart scripts directly from the CLI.
  • Added --introspection / -i <file> and --json-introspection <file> to inspect declaration metadata via CLI.
• feat: Output Redirection & Print Interception (onPrint)
  • Added onPrint: void Function(String)? callback to D4rt(...), d4rt.execute(...), d4rt.eval(...), and d4rt.executeCompiled(...) for capturing/redirecting script output.
• feat: dart:async Zones & Error Boundaries (runZoned & runZonedGuarded)
  • Added global runZoned and runZonedGuarded in dart:async standard library.
• feat: Introspection JSON Serialization (toMap & toJson)
  • Added toMap() and toJson() to IntrospectionResult, DeclarationInfo, FunctionInfo, ClassInfo, EnumInfo, VariableInfo, and ExtensionInfo.
• feat: Extension Type Support
  • Full support for Dart extension types, representation fields, custom constructors, methods, and getters/setters.
• feat: Precompiled Scripts & AST Caching (PrecompiledScript)
  • Added d4rt.compile(source: ...) to pre-parse and validate scripts without immediate execution.
  • Added d4rt.executeCompiled(script, ...) for high-performance repeated execution.
  • Added automatic AST caching support (D4rt(enableAstCache: true)).
• feat: Sandbox Execution Limits & Timeout Protection
  • Added timeout: Duration? and maxSteps: int? parameters to execute(), eval(), and executeCompiled().
  • Added ExecutionTimeoutException and ExecutionLimitException to guard against infinite loops and CPU runaway.
• feat: Interactive CLI & REPL Tool
  • Added command-line executable (bin/d4rt.dart & bin/interpreter.dart) to run Dart scripts or start an interactive REPL (dart run d4rt).
  • Interactive REPL features multiline statement input, environment persistence, and commands (:help, :clear, :exit).
• feat: Standard Library Enhancements & Completeness
  • Added dart:developer library with log(...), debugger(...), inspect(...), postEvent(...), registerExtension(...), Timeline, TimelineTask, UserTag, Service, and ServiceExtensionResponse.
  • Added Expando, RuneIterator, WeakReference, Finalizer, and Stopwatch in dart:core.
  • Extended StackTrace (StackTrace.fromString(...), StackTrace.current, StackTrace.empty) in dart:core.
  • Added DateTime.copyWith in dart:core.
  • Added BytesBuilder, Int64List, Uint64List, Int8List, Uint8ClampedList, Uint16List, Int32List, Uint32List, and Float64List in dart:typed_data.
  • Added Completer.sync() in dart:async.
  • Added LineSplitter.split(...) and hardened base64Encode/base64UrlEncode in dart:convert.
  • Added SplayTreeSet, DoubleLinkedQueue, UnmodifiableMapView, and UnmodifiableSetView in dart:collection.
  • Added MutableRectangle in dart:math.
  • Hardened Uri constructors and methods against dynamic collection arguments.
  • Enhanced universal runtime type subtyping (BridgedClass.isSubtypeOf).
• fix: Dart Web Platform Compatibility
  • Fixed runtime type resolution for int return types on Dart Web (#6).
  • Fixed property access and method calls on native JS collections like JSArray from String.split() (#8).

0.2.2

• feat: Extension Type Support
• New additional features & Bug fixes

0.2.1

• feat: Enum Support Enhancement
  • Add native-like values access for both interpreted and bridged enums.
• fix: Bridge Generator Improvements
  • Fix generic collection extraction syntax (remove extra spaces/invalid tags).
  • Prevent instantiation of abstract classes in generated bridges.
  • Remove redundant ?? null operators from generated code.
  • Fix aggressive type inference for common parameter names like key.

0.2.0

• misc:
  • Update analyzer to version 10.0.2.
  • Refactor deprecated fields.
  • Downgrade analyzer to version to 8.4.0
• feat: Bridge Code Generation Support
• feat: Library Tracking & Deduplication - Canonical source tracking for bridge deduplication

0.1.9

• feat:positionalArgs and namedArgs - Pass arguments directly to functions via execute()

  • Add positionalArgs parameter to D4rt.execute() for passing positional arguments
  • Add namedArgs parameter to D4rt.execute() for passing named arguments
  • Support complex data types (List, Map, nested structures) as arguments
  • Support function callbacks and async functions as arguments
  • Add 33 comprehensive test cases covering all argument passing patterns
  • Add parameter introspection methods: positionalParameterNames and namedParameterNames getters

• feat: Introspection API - Analyze code structure and get metadata at runtime

  • Add analyze() method to D4rt for code analysis without execution
  • Create IntrospectionResult with metadata about functions, classes, enums, variables, and extensions
  • Extract function signatures including parameter names, types, and default values
  • Extract class information: inheritance, mixins, interfaces, constructors, methods
  • Extract enum values and variants
  • Extract variable declarations and initializers
  • Extract extension definitions and extended types
  • Use AST-based analysis for accurate metadata extraction
  • Add 38 comprehensive test cases covering all declaration types and complex scenarios

• feat: eval() method - Dynamically execute code with current execution state

  • Add eval() method to D4rt for dynamic code execution
  • Preserve execution environment across eval calls
  • Support access to previously defined variables and functions
  • Support complex expressions and statements in eval
  • Support async/await in eval expressions
  • Add 39 comprehensive test cases covering expression evaluation and statement execution

• fix: Environment import handling - Tolerate duplicate imports with identical values

  • Allow re-importing the same symbol if the value is identical (same reference)
  • Use identical() comparison for duplicate detection
  • Support imports via multiple paths without conflict errors

0.1.8

• fix: security sandboxing with permission checks for file, process, and network operations; add platform access control

0.1.7

• feat: Security sandboxing system - Comprehensive permission-based security system to restrict dangerous operations
  • Implement modular permission system with FilesystemPermission, NetworkPermission, ProcessRunPermission, IsolatePermission
  • Block access to dangerous modules (dart:io, dart:isolate) by default unless explicitly granted
  • Add d4rt.grant(), d4rt.revoke(), d4rt.hasPermission() methods for permission management
  • Integrate permission checking into module loading and import directives
  • Support fine-grained permissions (specific paths, commands, network hosts)
  • Add comprehensive security tests to prevent malicious code execution
  • Enable safe execution environment for untrusted code

0.1.6

• fix: Nested for-in loops in async contexts now work correctly
• fix: Async nested for-in loops with await for streams works
• feat: enhance async execution state to support nested await-for loops and improve iterator management; add comprehensive tests for complex async scenarios
• feat: Compound super operators - Support for compound assignment operators on super properties (+=, -=, *=, /=, ~/=, %=, &=, |=, ^=, <<=, >>=, >>>=)
  • Implement proper lookup and evaluation of super properties in compound assignments
  • Support for both interpreted and bridged superclass properties
  • Add 6 comprehensive test cases covering all operator types and nested inheritance
• feat: Bridged static methods as values - Bridged static methods can now be treated as first-class function values
  • Support for accessing bridged static methods as callable values (e.g., int.parse)
  • Enable passing bridged static methods to higher-order functions
  • Store bridged static methods in collections and variables
  • Add 5 test cases for static method value usage patterns
• feat: Complex generic type checking - Enhanced runtime type checking for generic collections with type parameters
  • Support is operator with parameterized types (List
  • Runtime validation of generic type constraints
  • Proper handling of nested generic types and null safety
  • Add 10 comprehensive test cases for various generic type checking scenarios
• feat: Complex await assignments - Advanced await expression support in various contexts
  • Support await in conditional expressions (ternary operator)
  • Support await in list/map literals and collection operations
  • Support await in compound assignments and complex expressions
  • Support await in constructor arguments and method chains
  • Add 10 test cases covering complex async assignment patterns
• feat: Stream transformers - Complete implementation of StreamTransformer and stream manipulation
  • Implement StreamTransformer.fromHandlers with handleData, handleError, handleDone
  • Support stream transformation with custom logic
  • Implement bidirectional stream transformers
  • Support stream event handling and error propagation
  • Add 10 comprehensive test cases for stream transformation patterns
• feat: Const expressions complexes - Enhanced support for const expressions in various contexts
  • Support const List and Map literals with type parameters
  • Support const expressions in field initializers and default parameters
  • Support nested const collections and complex const expressions
  • Proper compile-time evaluation of const expressions
  • Add 15 test cases covering const expression usage patterns
• feat: Feature #7 - Enhanced enums with mixins - Enums can now use mixins to add functionality
  • Support enum Name with Mixin syntax
  • Mixins can add methods, getters, and properties to enum values
  • Support multiple mixins on a single enum
  • Full integration with enum values (index, name, toString)
  • Add 15 comprehensive test cases for enum-mixin combinations
• feat: Extensions statiques - Extensions can now declare static members (methods, getters, setters, fields)
  • Implement static member storage in InterpretedExtension class
  • Add static member access via Extension.member syntax
  • Support static method calls, property access, and assignments
  • Add support for prefix/postfix increment/decrement operators on static extension fields
  • Add 15 comprehensive test cases covering all static extension member types
• feat: Enhance compound super assignments for bridged classes - Full support for compound assignments on properties inherited from bridged superclasses
  • Fix visitAssignmentExpression to handle bridged superclass getters/setters in compound super assignments
  • Fix InterpretedInstance.get() to properly traverse bridged superclass hierarchy at each inheritance level
  • Fix InterpretedInstance.set() to properly handle bridged superclass setters at each inheritance level
  • Support nested inheritance chains (Interpreted → Interpreted → Bridged)
  • Add 5 comprehensive test cases for bridged super compound assignments
• Total test count: 1269 tests passing - All 8 planned features fully implemented with comprehensive test coverage

0.1.5

• feat: implement handling of factory constructors in InterpreterVisitor; add comprehensive tests for factory constructor behavior
• feat: enhance async execution state and interpreter visitor to support break/continue handling; add comprehensive tests for nested async loops
• feat: enhance async execution state and interpreter visitor to support async* generators; add comprehensive tests for generator behavior and control flow

0.1.4

• feat: add methods to find and retrieve bridged enum values in Environment and InterpreterVisitor; enhance handling of bridged enums in property access and binary expressions
• feat: enhance documentation across multiple files; add examples and clarify class functionalities in D4rt interpreter

0.1.3

• Implement complete late variable support with lazy initialization and proper error handling
• Add comprehensive late variable test coverage (33 test cases) including static fields, instance fields, final constraints, and error conditions
• Add LateVariable class with proper uninitialized access detection and assignment validation
• Enhance interpreter visitor to handle late variables in all contexts (local, static, instance)
• Fix nullable variable handling in interpreted class instances
• Add ComparableCore bridge to core standard library for better type comparison support
• Update documentation and project description for better clarity

0.1.2+1

• update project description in pubspec.yaml
• docs: minor updates to documentation in README.md

0.1.2

• Implement complete Isolate API with Capability, IsolateSpawnException, Isolate, SendPort, ReceivePort, RawReceivePort, RemoteError, and TransferableTypedData classes
• Add comprehensive isolate communication and message passing support
• Enhance async capabilities with Timer functionality and improved error handling
• Add UnawaitedAsync and TimeoutExceptionAsync classes for better async error management
• Implement additional HTTP methods and error handling in HttpClientIo
• Add toString method to DirectoryIo for better debugging
• Enhance FileSystemEntity with parentOf method and FileStat improvements
• Add FileSystemEvent static getters and methods
• Implement RawSocket and additional Socket classes for network programming
• Enhance Stream and Socket classes with additional utility methods
• Add IOSink, ProcessIo, and StringSink classes for improved I/O operations
• Implement Comparable interface for better type comparison support
• Add comprehensive test coverage for isolate, socket, and I/O functionality
• Update core typed data classes (Uint8List, Int16List, Float32List) with enhanced functionality
• Add list extension utilities for better collection manipulation

0.1.1

• Implement await for-in loop support for streams in interpreter
• Enhance pattern matching with support for rest elements in lists and maps
• Add support for await expressions in function and constructor arguments
• BREAKING CHANGE: BridgedClassDefinition has been removed and replaced with BridgedClass

0.1.0

• Added runtime checks for generic type constraints.
• Added support for compound bitwise assignment operators (&=, |=, etc.).
• Introduced Int16List and Float32List in typed_data.

0.0.9

• full support (generic classes/functions, type constraints, runtime validation)
• use BridgedClassDefinition for all Stdlib
• Support adjacent string literals in interpreter
• add operators support for InterpretedClass
• more features

0.0.8

• expose visitor getter
• add support for bridged mixins
• enhance async execution state with nested loop support

0.0.7

• fix: support null safety

0.0.6

• Update docs

0.0.5

• minor fix

0.0.4

• Add 'import/export' directive support, support for 'show' and 'hide' combinators
• Add some dart:collection & dart:typed_data
• Support for ParenthesizedExpression property access in simpleIdentifier in async state

0.0.3

• Fix infinite loop when using rethrow in try catch in async state

0.0.2

• Support web
• Fix return nativeValue for BridgedEnumValue to BridgedInstance argument

0.0.1

• Initial version.