render-workflows-dart 0.8.2

package/dart/generator/bin/generate.dart

@@ -0,0 +1,419 @@
+// Generates the two halves of a native task from an annotated Dart file.
+//
+// Reads a file containing `@nativeTask` top-level functions and writes:
+//
+//   <name>.g.dart          typed stubs, imported by the dart2js task code
+//   <name>.main.dart       the dispatcher main(), which is what compiles AOT
+//
+// The analyzer is used rather than pattern matching because the stubs have to
+// reproduce parameter names, defaults, nullability and generics exactly — a
+// regex that is right most of the time would produce code that fails to
+// compile in ways the author cannot fix.
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:analyzer/dart/analysis/analysis_context_collection.dart';
+import 'package:analyzer/dart/analysis/results.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/nullability_suffix.dart';
+import 'package:analyzer/dart/element/type.dart';
+
+Future<int> main(List<String> argv) async {
+  final args = _parseArgs(argv);
+  final project = args['project']!;
+  final entry = args['entry']!;
+  final name = args['name']!;
+  final stubPath = args['stub']!;
+  final mainPath = args['main']!;
+  final facadePath = args['facade']!;
+  // package.json overrides the annotation; absent means "annotation decides".
+  final override = _Options(
+    worker: args['worker'] == null ? null : args['worker'] == 'true',
+    idleTimeoutMs: int.tryParse(args['idle'] ?? ''),
+    timeoutMs: int.tryParse(args['timeout'] ?? ''),
+  );
+
+  final collection = AnalysisContextCollection(includedPaths: [project, entry]);
+  final session = collection.contextFor(entry).currentSession;
+  final resolved = await session.getResolvedLibrary(entry);
+
+  if (resolved is! ResolvedLibraryResult) {
+    return _fail('could not analyse $entry: $resolved');
+  }
+
+  final errors = <String>[];
+  for (final unit in resolved.units) {
+    for (final d in unit.diagnostics) {
+      if (d.severity.name == 'ERROR') {
+        errors.add('  ${d.message} (line ${unit.lineInfo.getLocation(d.offset).lineNumber})');
+      }
+    }
+  }
+  if (errors.isNotEmpty) {
+    return _fail('${_rel(project, entry)} does not analyse cleanly:\n${errors.join('\n')}');
+  }
+
+  final fns = resolved.element.topLevelFunctions.where(_isNativeTask).toList();
+  if (fns.isEmpty) {
+    return _fail(
+      'no @nativeTask functions in ${_rel(project, entry)}.\n'
+      'Annotate a top-level function with @nativeTask, or declare this entry '
+      'with "mode": "exe" if it owns its own main().',
+    );
+  }
+
+  final problems = <String>[];
+  for (final fn in fns) {
+    problems.addAll(_validate(fn));
+  }
+  if (problems.isNotEmpty) {
+    return _fail(
+      'these @nativeTask signatures cannot cross a JSON boundary:\n'
+      '${problems.map((p) => '  $p').join('\n')}\n\n'
+      'Supported: bool, int, double, num, String, List<T>, Map<String, T>, '
+      'Object?, dynamic, and Future<T> of those.',
+    );
+  }
+
+  File(stubPath)
+    ..createSync(recursive: true)
+    ..writeAsStringSync(_stubs(name, fns, stubPath, project, override));
+  File(facadePath)
+    ..createSync(recursive: true)
+    ..writeAsStringSync(_facade(name, stubPath, facadePath, entry));
+  File(mainPath)
+    ..createSync(recursive: true)
+    ..writeAsStringSync(_dispatcher(name, fns, mainPath, entry, project));
+
+  stdout.writeln(jsonEncode({
+    'name': name,
+    'methods': [for (final f in fns) f.name],
+  }));
+  return 0;
+}
+
+// ---------------------------------------------------------------- annotations
+
+/// Effective settings for one native task.
+class _Options {
+  const _Options({this.worker, this.idleTimeoutMs, this.timeoutMs});
+
+  final bool? worker;
+  final int? idleTimeoutMs;
+  final int? timeoutMs;
+
+  /// [other] wins where it has an opinion. Used for package.json over the
+  /// annotation, so a deployment can change behaviour without editing code.
+  _Options overriddenBy(_Options other) => _Options(
+        worker: other.worker ?? worker,
+        idleTimeoutMs: other.idleTimeoutMs ?? idleTimeoutMs,
+        timeoutMs: other.timeoutMs ?? timeoutMs,
+      );
+}
+
+/// Reads `@NativeTask(...)` arguments off the function.
+_Options _optionsOf(TopLevelFunctionElement fn) {
+  for (final a in fn.metadata.annotations) {
+    final value = a.computeConstantValue();
+    if (value?.type?.element?.name != 'NativeTask') continue;
+
+    // A const Duration exposes its microseconds as a field on the constant.
+    // Current SDKs name it `inMicroseconds`; older ones used the private
+    // `_duration`, so both are tried rather than silently reading null and
+    // falling back to a default the author did not ask for.
+    int? ms(String field) {
+      final duration = value!.getField(field);
+      if (duration == null || duration.isNull) return null;
+
+      final micros = duration.getField('inMicroseconds')?.toIntValue() ??
+          duration.getField('_duration')?.toIntValue();
+      if (micros == null) {
+        stderr.writeln(
+          'warning: could not read $field from @NativeTask on ${fn.name}; '
+          'using the default instead',
+        );
+        return null;
+      }
+      return micros ~/ 1000;
+    }
+
+    return _Options(
+      worker: value!.getField('worker')?.toBoolValue(),
+      idleTimeoutMs: ms('idleTimeout'),
+      timeoutMs: ms('timeout'),
+    );
+  }
+  return const _Options();
+}
+
+bool _isNativeTask(TopLevelFunctionElement fn) {
+  for (final a in fn.metadata.annotations) {
+    // Matches both `@nativeTask` (a const instance) and `@NativeTask()`.
+    final value = a.computeConstantValue();
+    final typeName = value?.type?.element?.name;
+    if (typeName == 'NativeTask') return true;
+  }
+  return false;
+}
+
+// ----------------------------------------------------------------- validation
+
+/// Unwraps `Future<T>` to `T`; other types are returned unchanged.
+DartType _unwrapFuture(DartType t) {
+  if (t is InterfaceType && t.isDartAsyncFuture && t.typeArguments.length == 1) {
+    return t.typeArguments.single;
+  }
+  return t;
+}
+
+bool _jsonable(DartType t) {
+  if (t is VoidType || t is DynamicType) return true;
+  if (t.isDartCoreBool || t.isDartCoreInt || t.isDartCoreDouble) return true;
+  if (t.isDartCoreNum || t.isDartCoreString || t.isDartCoreNull) return true;
+  if (t.isDartCoreObject) return true;
+  if (t is InterfaceType) {
+    if (t.isDartCoreList) return _jsonable(t.typeArguments.single);
+    if (t.isDartCoreMap) {
+      return t.typeArguments[0].isDartCoreString && _jsonable(t.typeArguments[1]);
+    }
+  }
+  return false;
+}
+
+List<String> _validate(TopLevelFunctionElement fn) {
+  final out = <String>[];
+  final ret = _unwrapFuture(fn.returnType);
+  if (!_jsonable(ret)) {
+    out.add('${fn.name}: return type ${_display(fn.returnType)}');
+  }
+  for (final p in fn.formalParameters) {
+    if (!_jsonable(p.type)) {
+      out.add('${fn.name}: parameter "${p.name}" of type ${_display(p.type)}');
+    }
+  }
+  return out;
+}
+
+// -------------------------------------------------------------------- codegen
+
+String _display(DartType t) => t.getDisplayString();
+
+bool _nullable(DartType t) =>
+    t.nullabilitySuffix == NullabilitySuffix.question || t is DynamicType;
+
+/// A Dart expression converting `expr` (raw decoded JSON) into [t].
+///
+/// A plain `as` cast is not enough: jsonDecode produces `List<dynamic>` and
+/// `Map<String, dynamic>`, so `as List<int>` throws even when every element is
+/// an int. Collections are rebuilt element by element, and doubles go through
+/// num because JSON does not distinguish 3 from 3.0.
+String _decode(DartType t, String expr) {
+  if (t is VoidType || t is DynamicType || t.isDartCoreObject) return expr;
+
+  final q = _nullable(t);
+  final bang = q ? '?' : '';
+
+  if (t.isDartCoreDouble) {
+    return q ? '($expr as num?)?.toDouble()' : '($expr as num).toDouble()';
+  }
+  if (t.isDartCoreBool || t.isDartCoreInt || t.isDartCoreNum || t.isDartCoreString) {
+    return '$expr as ${_display(t)}';
+  }
+  if (t is InterfaceType && t.isDartCoreList) {
+    final e = t.typeArguments.single;
+    return '($expr as List$bang)$bang.map((e) => ${_decode(e, 'e')}).toList()';
+  }
+  if (t is InterfaceType && t.isDartCoreMap) {
+    final v = t.typeArguments[1];
+    return '($expr as Map$bang)$bang.map((k, e) => '
+        'MapEntry(k as String, ${_decode(v, 'e')}))';
+  }
+  return expr;
+}
+
+String _rel(String from, String to) {
+  final f = Directory(from).absolute.path.split(Platform.pathSeparator);
+  final t = File(to).absolute.path.split(Platform.pathSeparator);
+  var i = 0;
+  while (i < f.length && i < t.length && f[i] == t[i]) i++;
+  return [...List.filled(f.length - i, '..'), ...t.sublist(i)].join('/');
+}
+
+/// Import path from the file at [fromFile] to [toFile].
+String _importPath(String fromFile, String toFile) =>
+    _rel(File(fromFile).parent.path, toFile);
+
+String _header(String name) => '''
+// GENERATED by render-dart from a @nativeTask source. Do not edit.
+//
+// Regenerated by `render-dart build`; changes here are overwritten.
+''';
+
+String _stubs(
+  String name,
+  List<TopLevelFunctionElement> fns,
+  String stubPath,
+  String project,
+  _Options override,
+) {
+  final b = StringBuffer(_header(name))
+    ..writeln("import '${_importPath(stubPath, '$project/render_dart.dart')}';")
+    ..writeln();
+
+  for (final fn in fns) {
+    final ret = _unwrapFuture(fn.returnType);
+    final isVoid = ret is VoidType;
+    final sig = _stubSignature(fn);
+    final positional = fn.formalParameters.where((p) => !p.isNamed).toList();
+    final named = fn.formalParameters.where((p) => p.isNamed).toList();
+
+    final args = '[${positional.map((p) => p.name).join(', ')}]';
+    final namedMap = named.isEmpty
+        ? 'const {}'
+        : '{${named.map((p) => "'${p.name}': ${p.name}").join(', ')}}';
+
+    b
+      ..writeln('/// Runs `${fn.name}` in the `$name` native executable.')
+      ..writeln('Future<${isVoid ? 'void' : _display(ret)}> $sig async {');
+    // Settings ride with the declaration, so nothing at the call site has to
+    // know this is native.
+    final o = _optionsOf(fn).overriddenBy(override);
+    final tail = (o.worker ?? false)
+        ? ', true, ${o.idleTimeoutMs ?? 30000}, ${o.timeoutMs ?? 0}'
+        : (o.timeoutMs != null ? ', false, 30000, ${o.timeoutMs}' : '');
+    final call = "callNativeTask('$name', '${fn.name}', $args, $namedMap$tail)";
+    if (isVoid) {
+      b.writeln('  await $call;');
+    } else {
+      b
+        ..writeln('  final r = await $call;')
+        ..writeln('  return ${_decode(ret, 'r')};');
+    }
+    b
+      ..writeln('}')
+      ..writeln();
+  }
+  return b.toString();
+}
+
+String _stubSignature(TopLevelFunctionElement fn) {
+  final positional = <String>[];
+  final optional = <String>[];
+  final named = <String>[];
+
+  for (final p in fn.formalParameters) {
+    final decl = '${_display(p.type)} ${p.name}';
+    if (p.isNamed) {
+      final def = p.hasDefaultValue ? ' = ${p.defaultValueCode}' : '';
+      named.add(p.isRequiredNamed ? 'required $decl' : '$decl$def');
+    } else if (p.isOptionalPositional) {
+      optional.add(p.hasDefaultValue ? '$decl = ${p.defaultValueCode}' : decl);
+    } else {
+      positional.add(decl);
+    }
+  }
+
+  final parts = [
+    ...positional,
+    if (optional.isNotEmpty) '[${optional.join(', ')}]',
+    if (named.isNotEmpty) '{${named.join(', ')}}',
+  ];
+  return '${fn.name}(${parts.join(', ')})';
+}
+
+/// The file callers import.
+///
+/// A conditional export, so the same import resolves to the real
+/// implementation when compiled AOT and to the process-spawning stub under
+/// dart2js. That is what lets task code call a native task by its plain name
+/// with no knowledge that it is native — and lets native code calling a
+/// sibling native function skip the process hop entirely.
+String _facade(String name, String stubPath, String facadePath, String entry) => '''
+${_header(name)}// Callers import this file, not the implementation beside it.
+//
+// Under dart2js `dart.library.io` is false, so this resolves to the stub that
+// spawns the executable. Compiled AOT it resolves to the implementation and the
+// call is direct.
+//
+// Always `await` a native task: the stub returns a Future where the
+// implementation may return a plain value, so awaiting is what makes one piece
+// of code compile against both.
+export '${_importPath(facadePath, stubPath)}'
+    if (dart.library.io) '${_importPath(facadePath, entry)}';
+''';
+
+String _dispatcher(
+  String name,
+  List<TopLevelFunctionElement> fns,
+  String mainPath,
+  String entry,
+  String project,
+) {
+  final b = StringBuffer(_header(name))
+    ..writeln("import '${_importPath(mainPath, entry)}';")
+    ..writeln("import '${_importPath(mainPath, '$project/native_task.dart')}';")
+    ..writeln()
+    ..writeln('Future<void> main(List<String> args) => nativeTaskMain(args, {');
+
+  for (final fn in fns) {
+    final call = <String>[];
+    var i = 0;
+    for (final p in fn.formalParameters) {
+      if (p.isNamed) {
+        final fallback = p.hasDefaultValue
+            ? p.defaultValueCode!
+            : (_nullable(p.type) ? 'null' : "_missing('${fn.name}', '${p.name}')");
+        call.add(
+          "${p.name}: n.containsKey('${p.name}') "
+          '? ${_decode(p.type, "n['${p.name}']")} : $fallback',
+        );
+      } else {
+        final idx = i++;
+        final read = _decode(p.type, 'a[$idx]');
+        if (p.isOptionalPositional) {
+          final fallback = p.hasDefaultValue
+              ? p.defaultValueCode!
+              : (_nullable(p.type) ? 'null' : "_missing('${fn.name}', '${p.name}')");
+          call.add('a.length > $idx ? $read : $fallback');
+        } else {
+          call.add(read);
+        }
+      }
+    }
+    b.writeln("  '${fn.name}': (a, n) async => ${fn.name}(${call.join(', ')}),");
+  }
+
+  b.writeln('});');
+
+  final body = b.toString();
+  if (!body.contains('_missing(')) return body;
+
+  return '$body\n'
+      'Never _missing(String fn, String param) =>\n'
+      "    throw ArgumentError('\$fn requires the parameter \"\$param\"');\n";
+}
+
+// ------------------------------------------------------------------- plumbing
+
+Map<String, String> _parseArgs(List<String> argv) {
+  final out = <String, String>{};
+  for (var i = 0; i < argv.length; i++) {
+    if (argv[i].startsWith('--')) out[argv[i].substring(2)] = argv[++i];
+  }
+  for (final k in ['project', 'entry', 'name', 'stub', 'main', 'facade']) {
+    if (!out.containsKey(k)) {
+      stderr.writeln('generate.dart: missing --$k');
+      exit(2);
+    }
+  }
+  return out;
+}
+
+int _fail(String message) {
+  stderr.writeln(message);
+  // An async main's return value is NOT the process exit code — only a
+  // synchronous `int main()` works that way. Setting exitCode is what actually
+  // makes the build fail instead of silently continuing with no output.
+  exitCode = 1;
+  return 1;
+}

package/dart/generator/pubspec.lock

@@ -0,0 +1,149 @@
+# Generated by pub
+# See https://dart.dev/tools/pub/glossary#lockfile
+packages:
+  _fe_analyzer_shared:
+    dependency: transitive
+    description:
+      name: _fe_analyzer_shared
+      sha256: "9a3386eea899815698dd55995277cf7cb8572ee52b399a6edfb7ae2b50e5fc19"
+      url: "https://pub.dev"
+    source: hosted
+    version: "105.0.0"
+  analyzer:
+    dependency: "direct main"
+    description:
+      name: analyzer
+      sha256: "62993bed6eadbe9596c5c20d5c167e7bc563c5fe266657a04ddeb93bdb84f4c9"
+      url: "https://pub.dev"
+    source: hosted
+    version: "14.1.0"
+  async:
+    dependency: transitive
+    description:
+      name: async
+      sha256: e2eb0491ba5ddb6177742d2da23904574082139b07c1e33b8503b9f46f3e1a37
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.13.1"
+  collection:
+    dependency: transitive
+    description:
+      name: collection
+      sha256: "2f5709ae4d3d59dd8f7cd309b4e023046b57d8a6c82130785d2b0e5868084e76"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.19.1"
+  convert:
+    dependency: transitive
+    description:
+      name: convert
+      sha256: b30acd5944035672bc15c6b7a8b47d773e41e2f17de064350988c5d02adb1c68
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.1.2"
+  crypto:
+    dependency: transitive
+    description:
+      name: crypto
+      sha256: c8ea0233063ba03258fbcf2ca4d6dadfefe14f02fab57702265467a19f27fadf
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.0.7"
+  file:
+    dependency: transitive
+    description:
+      name: file
+      sha256: a3b4f84adafef897088c160faf7dfffb7696046cb13ae90b508c2cbc95d3b8d4
+      url: "https://pub.dev"
+    source: hosted
+    version: "7.0.1"
+  glob:
+    dependency: transitive
+    description:
+      name: glob
+      sha256: c3f1ee72c96f8f78935e18aa8cecced9ab132419e8625dc187e1c2408efc20de
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.1.3"
+  meta:
+    dependency: transitive
+    description:
+      name: meta
+      sha256: "307249ce4ff29d58a18e97f6345f539382eb9c9c29ecda628900f31de0443dd9"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.19.0"
+  package_config:
+    dependency: transitive
+    description:
+      name: package_config
+      sha256: ffcf4cf3d6c0b74ac43708d9f56625506e8a68aa935abe9d267a7330f320eb5d
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.0.0"
+  path:
+    dependency: transitive
+    description:
+      name: path
+      sha256: "75cca69d1490965be98c73ceaea117e8a04dd21217b37b292c9ddbec0d955bc5"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.9.1"
+  pub_semver:
+    dependency: transitive
+    description:
+      name: pub_semver
+      sha256: "5bfcf68ca79ef689f8990d1160781b4bad40a3bd5e5218ad4076ddb7f4081585"
+      url: "https://pub.dev"
+    source: hosted
+    version: "2.2.0"
+  source_span:
+    dependency: transitive
+    description:
+      name: source_span
+      sha256: "56a02f1f4cd1a2d96303c0144c93bd6d909eea6bee6bf5a0e0b685edbd4c47ab"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.10.2"
+  string_scanner:
+    dependency: transitive
+    description:
+      name: string_scanner
+      sha256: "921cd31725b72fe181906c6a94d987c78e3b98c2e205b397ea399d4054872b43"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.4.1"
+  term_glyph:
+    dependency: transitive
+    description:
+      name: term_glyph
+      sha256: "7f554798625ea768a7518313e58f83891c7f5024f88e46e7182a4558850a4b8e"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.2.2"
+  typed_data:
+    dependency: transitive
+    description:
+      name: typed_data
+      sha256: f9049c039ebfeb4cf7a7104a675823cd72dba8297f264b6637062516699fa006
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.4.0"
+  watcher:
+    dependency: transitive
+    description:
+      name: watcher
+      sha256: "1398c9f081a753f9226febe8900fce8f7d0a67163334e1c94a2438339d79d635"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.2.1"
+  yaml:
+    dependency: transitive
+    description:
+      name: yaml
+      sha256: b9da305ac7c39faa3f030eccd175340f968459dae4af175130b3fc47e40d76ce
+      url: "https://pub.dev"
+    source: hosted
+    version: "3.1.3"
+sdks:
+  dart: ">=3.13.0 <4.0.0"

package/dart/generator/pubspec.yaml

@@ -0,0 +1,9 @@
+name: render_dart_generator
+description: Generates native-task dispatchers and typed stubs for render-dart.
+publish_to: none
+
+environment:
+  sdk: ^3.13.0
+
+dependencies:
+  analyzer: any

package/examples/README.md

@@ -0,0 +1,56 @@
+# Examples
+
+Each directory is a complete, runnable Render Workflows service — and also a
+template:
+
+```bash
+npx render-workflows-dart init my-app --template postgres
+```
+
+That is deliberate. A template that is not also a working example drifts from
+reality; making them the same thing means every template is one you can run.
+
+| | Answers |
+| --- | --- |
+| [`default/`](default) | How do I write a task, fan work out, and retry a failure? |
+| [`http/`](http) | How do I call an external API? |
+| [`native/`](native) | How do I read a file, shell out, or use more than one core? |
+| [`postgres/`](postgres) | How do I reach a database? |
+| [`introspect/`](introspect) | How do I inspect Render, or run a task in another workflow? |
+
+## Running one
+
+```bash
+cd http
+npm install
+npx render-dart dev
+```
+
+Then, in another terminal:
+
+```bash
+render workflows tasks list --local
+render workflows start fetchRepo --local --input='["dart-lang/sdk"]'
+```
+
+No Dart installation is needed — a pinned SDK is fetched into `node_modules`.
+
+## Which escape hatch
+
+dart2js runs task bodies, and covers most work. It cannot open a file, use a
+second core, or run a package that needs `dart:io`.
+
+- **HTTP is not one of those cases.** `package:http` works, because its web
+  implementation goes through the platform's networking. See `http/`.
+- **A package shipping WebAssembly** runs in-process with nothing spawned.
+  Prefer it when one exists.
+- **Everything else** — files, FFI, databases, real parallelism — is a native
+  task. See `native/` and `postgres/`.
+
+Native is **not** faster at arithmetic; V8 matches Dart AOT on integer work.
+Choose it for reach, or for parallelism, which is the one real speed win.
+
+## A note on dependencies
+
+`postgres/seed` and `introspect/` depend on `render_api` by **git**, because it
+is not on pub.dev yet. Those become ordinary version constraints once it is.

package/examples/default/README.md

@@ -0,0 +1,18 @@
+# default
+
+The Workflows basics, with no dependencies beyond the SDK. This is what
+`render-dart init` produces with no `--template`.
+
+| Task | Shows |
+| --- | --- |
+| `calculateSquare` | A leaf task: arguments in, JSON out |
+| `sumSquares` | Fan-out — each `callTask` is its own run on its own instance |
+| `flaky` | Retry policy, and a failure reaching Render with its real message |
+
+```bash
+npm install && npx render-dart dev
+render workflows start sumSquares --local --input='[[2, 3, 4]]'   # 29
+```
+
+`callTask` starts a **subtask of this workflow**. Reaching a task in a
+*different* service goes through the API instead — see [`../introspect`](../introspect).

package/examples/default/gitignore

@@ -0,0 +1,7 @@
+node_modules/
+build/
+.dart_tool/
+.dart-sdk/
+pubspec.lock
+.env
+.DS_Store

package/examples/default/index.js

@@ -0,0 +1,2 @@
+// Render runs this as the start command.
+require('render-dart/runtime').runTasks('./build/tasks.js');

package/examples/default/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "dart-workflow",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "build": "render-dart build",
+    "start": "node index.js",
+    "dev": "render-dart dev"
+  },
+  "dependencies": {
+    "@renderinc/sdk": "^0.6.0",
+    "render-dart": "^0.7.1"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/examples/default/pubspec.yaml

@@ -0,0 +1,7 @@
+name: dart_workflow
+description: Render Workflows tasks written in Dart.
+publish_to: none
+version: 0.1.0
+
+environment:
+  sdk: ^3.10.0