Update changes

Author: MelbourneDeveloper

packages/dart_node_coverage/bin/coverage.dart

@@ -170,6 +170,8 @@ Future<Result<void, String>> _instrumentFileInPlace(String filePath) async {
   final parseResult = parseExecutableLines(source, filePath);
   switch (parseResult) {
     case Success(:final value):
+      final relativePath = p.relative(filePath);
+      stdout.writeln('  $relativePath: ${value.length} executable lines');
       final instrumentResult = instrumentSource(
         sourceCode: source,
         filePath: filePath,
@@ -210,19 +212,19 @@ Future<Result<void, String>> _runTests(String packageDir) async {
       ? {'NODE_PATH': p.join(packageDir, 'node_modules')}
       : <String, String>{};
 
-  final result = await Process.run(
+  final process = await Process.start(
     'dart',
     testArgs,
     workingDirectory: packageDir,
     environment: environment,
+    mode: ProcessStartMode.inheritStdio,
   );
 
-  stdout.writeln('Test stdout: ${result.stdout}');
-  stderr.writeln('Test stderr: ${result.stderr}');
+  final exitCode = await process.exitCode;
 
-  return result.exitCode == 0
+  return exitCode == 0
       ? const Success<void, String>(null)
-      : Error<void, String>('Tests failed with exit code ${result.exitCode}');
+      : Error<void, String>('Tests failed with exit code $exitCode');
 }
 
 Result<void, String> _generateLcov(String packageDir, String outputPath) {

packages/dart_node_coverage/lib/src/instrumenter.dart

@@ -62,24 +62,31 @@ Result<String, String> instrumentSource({
 }
 
 /// Find the index where the coverage import should be inserted.
-/// After library directive if present, otherwise after existing imports,
-/// or at the top if no imports.
+/// After the last import/export directive (including multi-line ones),
+/// after library directive, or at the top.
 int _findImportInsertIndex(List<String> lines) {
-  var lastImportIndex = -1;
+  var lastDirectiveEnd = -1;
   var libraryIndex = -1;
+  var inDirective = false;
 
   for (var i = 0; i < lines.length; i++) {
     final trimmed = lines[i].trim();
     if (trimmed.startsWith('library')) libraryIndex = i;
-    if (trimmed.startsWith('import ')) lastImportIndex = i;
+    final startsDirective =
+        trimmed.startsWith('import ') || trimmed.startsWith('export ');
+    if (startsDirective) inDirective = true;
+    if (inDirective && trimmed.endsWith(';')) {
+      lastDirectiveEnd = i;
+      inDirective = false;
+    }
   }
 
-  // Insert after last import, or after library, or at top
-  return lastImportIndex >= 0
-      ? lastImportIndex + 1
+  // Insert after last directive end, or after library, or at top
+  return lastDirectiveEnd >= 0
+      ? lastDirectiveEnd + 1
       : libraryIndex >= 0
-      ? libraryIndex + 1
-      : 0;
+          ? libraryIndex + 1
+          : 0;
 }
 
 /// Inject coverage probe at the start of a line.

packages/dart_node_sql_js/lib/dart_node_sql_js.dart

@@ -0,0 +1,9 @@
+/// Typed Dart bindings for sql.js (SQLite compiled to WebAssembly).
+///
+/// Provides synchronous SQLite3 access via WebAssembly.
+/// Call [initializeSqlJs] once at startup, then use [openDatabase].
+library;
+
+export 'src/database.dart';
+export 'src/statement.dart';
+export 'src/types.dart';

packages/dart_node_sql_js/lib/src/database.dart

@@ -0,0 +1,173 @@
+/// Database bindings for sql.js (SQLite compiled to WebAssembly).
+library;
+
+import 'dart:js_interop';
+import 'dart:js_interop_unsafe';
+
+import 'package:dart_node_core/dart_node_core.dart';
+import 'package:dart_node_sql_js/src/statement.dart';
+import 'package:nadz/nadz.dart';
+
+/// Pre-initialized sql.js runtime.
+///
+/// Obtained from [initializeSqlJs], passed to [openDatabase].
+typedef SqlJsRuntime = ({JSFunction databaseConstructor});
+
+/// Initialize sql.js. Call once at startup.
+///
+/// Returns a [SqlJsRuntime] that must be passed to [openDatabase].
+Future<Result<SqlJsRuntime, String>> initializeSqlJs() async {
+  try {
+    final initFn = requireModule('sql.js') as JSFunction;
+    final promise = initFn.callAsFunction(null) as JSPromise<JSAny?>;
+    final sqlJs = await promise.toDart as JSObject;
+    final dbConstructor = sqlJs['Database'] as JSFunction;
+    return Success((databaseConstructor: dbConstructor));
+  } catch (e) {
+    return Error('Failed to initialize sql.js: $e');
+  }
+}
+
+/// A sql.js database connection.
+typedef Database = ({
+  /// Prepare a SQL statement.
+  Result<Statement, String> Function(String sql) prepare,
+
+  /// Execute raw SQL (no results).
+  Result<void, String> Function(String sql) exec,
+
+  /// Close the database.
+  Result<void, String> Function() close,
+
+  /// Set a pragma value.
+  Result<void, String> Function(String pragmaValue) pragma,
+
+  /// Check if database is open.
+  bool Function() isOpen,
+});
+
+/// Open a sql.js database.
+///
+/// If [path] points to an existing file, loads it.
+/// Otherwise creates a new empty database.
+/// Auto-persists to disk after write operations.
+Result<Database, String> openDatabase(
+  String path, {
+  required SqlJsRuntime sqlJs,
+}) {
+  try {
+    final fs = requireModule('fs') as JSObject;
+    final existsSyncFn = fs['existsSync'] as JSFunction;
+    final readFileSyncFn = fs['readFileSync'] as JSFunction;
+
+    JSObject jsDb;
+    final fileExists =
+        (existsSyncFn.callAsFunction(fs, path.toJS) as JSBoolean).toDart;
+
+    if (fileExists) {
+      final buffer = readFileSyncFn.callAsFunction(fs, path.toJS);
+      jsDb = sqlJs.databaseConstructor
+          .callAsConstructor<JSObject>(buffer);
+    } else {
+      jsDb = sqlJs.databaseConstructor.callAsConstructor<JSObject>();
+    }
+
+    // sql.js is in-memory; WAL and busy_timeout do not apply.
+    // Enable foreign keys for referential integrity.
+    _dbRun(jsDb, 'PRAGMA foreign_keys = ON');
+
+    return Success(_createDatabase(jsDb, path, fs));
+  } catch (e) {
+    return Error('Failed to open database: $e');
+  }
+}
+
+/// Run a SQL statement directly on the JS database object.
+void _dbRun(JSObject jsDb, String sql) {
+  (jsDb['run'] as JSFunction).callAsFunction(jsDb, sql.toJS);
+}
+
+/// Persist the in-memory database to disk.
+void _save(JSObject jsDb, String path, JSObject fs) {
+  final exportFn = jsDb['export'] as JSFunction;
+  final data = exportFn.callAsFunction(jsDb);
+
+  final bufferClass = requireModule('buffer') as JSObject;
+  final bufferFrom =
+      (bufferClass['Buffer'] as JSObject)['from'] as JSFunction;
+  final nodeBuffer = bufferFrom.callAsFunction(null, data);
+
+  final writeFileSyncFn = fs['writeFileSync'] as JSFunction;
+  writeFileSyncFn.callAsFunction(fs, path.toJS, nodeBuffer);
+}
+
+Database _createDatabase(JSObject jsDb, String path, JSObject fs) {
+  var open = true;
+
+  return (
+    prepare: (sql) => _dbPrepare(jsDb, sql, path, fs),
+    exec: (sql) => _dbExec(jsDb, sql, path, fs),
+    close: () => _dbClose(jsDb, path, fs, () => open = false),
+    pragma: (pragmaValue) => _dbPragma(jsDb, pragmaValue),
+    isOpen: () => open,
+  );
+}
+
+Result<Statement, String> _dbPrepare(
+  JSObject jsDb,
+  String sql,
+  String path,
+  JSObject fs,
+) {
+  try {
+    final prepareFn = jsDb['prepare'] as JSFunction;
+    final jsStmt =
+        prepareFn.callAsFunction(jsDb, sql.toJS) as JSObject;
+    return Success(
+      createStatement(jsStmt, jsDb, onWrite: () => _save(jsDb, path, fs)),
+    );
+  } catch (e) {
+    return Error('Failed to prepare statement: $e');
+  }
+}
+
+Result<void, String> _dbExec(
+  JSObject jsDb,
+  String sql,
+  String path,
+  JSObject fs,
+) {
+  try {
+    // sql.js exec() handles multiple statements separated by ;
+    (jsDb['exec'] as JSFunction).callAsFunction(jsDb, sql.toJS);
+    _save(jsDb, path, fs);
+    return const Success(null);
+  } catch (e) {
+    return Error('Failed to exec: $e');
+  }
+}
+
+Result<void, String> _dbClose(
+  JSObject jsDb,
+  String path,
+  JSObject fs,
+  void Function() markClosed,
+) {
+  try {
+    _save(jsDb, path, fs);
+    (jsDb['close'] as JSFunction).callAsFunction(jsDb);
+    markClosed();
+    return const Success(null);
+  } catch (e) {
+    return Error('Failed to close database: $e');
+  }
+}
+
+Result<void, String> _dbPragma(JSObject jsDb, String pragmaValue) {
+  try {
+    _dbRun(jsDb, 'PRAGMA $pragmaValue');
+    return const Success(null);
+  } catch (e) {
+    return Error('Failed to set pragma: $e');
+  }
+}