mrmd-js 2.0.0 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mrmd-js",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "MRP-compliant browser JavaScript runtime for mrmd notebooks",
   "type": "module",
   "main": "dist/index.cjs",

package/src/execute/javascript.js

@@ -88,7 +88,19 @@ export class JavaScriptExecutor extends BaseExecutor {
 
     try {
       // Execute in context (pass execId for input() support)
-      const rawResult = await context.execute(wrapped, { execId: options.execId });
+      let rawResult = await context.execute(wrapped, { execId: options.execId });
+
+      // Auto-await if result is a Promise (catch cases not handled by auto-await transform)
+      if (rawResult.result && typeof rawResult.result === 'object' && typeof rawResult.result.then === 'function') {
+        try {
+          rawResult.result = await rawResult.result;
+        } catch (promiseError) {
+          // Promise rejected - treat as error
+          rawResult.error = promiseError instanceof Error ? promiseError : new Error(String(promiseError));
+          rawResult.result = undefined;
+        }
+      }
+
       const duration = performance.now() - startTime;
 
       // Format result

package/src/session/console-capture.js

@@ -9,6 +9,15 @@
  * @typedef {import('./context/interface.js').LogEntry} LogEntry
  */
 
+/**
+ * Check if a value is a Promise
+ * @param {*} value
+ * @returns {boolean}
+ */
+function isPromise(value) {
+  return value && typeof value === 'object' && typeof value.then === 'function';
+}
+
 /**
  * Format arguments for logging
  * @param {Array<*>} args
@@ -31,6 +40,21 @@ function formatArgs(args) {
     .join(' ');
 }
 
+/**
+ * Check args for Promises and return warning message if found
+ * @param {Array<*>} args
+ * @returns {string | null}
+ */
+function checkForPromises(args) {
+  for (const arg of args) {
+    if (isPromise(arg)) {
+      return '⚠️  Promise detected - this value needs to be awaited. ' +
+             'Add "await" before the async call, or assign it to get the resolved value.';
+    }
+  }
+  return null;
+}
+
 /**
  * Create a console capture for a window context
  */
@@ -73,11 +97,23 @@ export class ConsoleCapture {
     // Intercept methods
     console.log = (...args) => {
       this.#queue.push({ type: 'log', args, timestamp: Date.now() });
+      // Check for unresolved Promises and warn
+      const promiseWarning = checkForPromises(args);
+      if (promiseWarning) {
+        this.#queue.push({ type: 'warn', args: [promiseWarning], timestamp: Date.now() });
+        this.#originalConsole?.warn?.(promiseWarning);
+      }
       this.#originalConsole?.log?.(...args);
     };
 
     console.info = (...args) => {
       this.#queue.push({ type: 'info', args, timestamp: Date.now() });
+      // Check for unresolved Promises and warn
+      const promiseWarning = checkForPromises(args);
+      if (promiseWarning) {
+        this.#queue.push({ type: 'warn', args: [promiseWarning], timestamp: Date.now() });
+        this.#originalConsole?.warn?.(promiseWarning);
+      }
       this.#originalConsole?.info?.(...args);
     };
 

package/src/transform/async.js

@@ -1,12 +1,130 @@
 /**
  * Async Transform
  *
- * Wraps code to support top-level await.
+ * Wraps code to support top-level await and auto-awaits common async patterns.
+ * This makes JavaScript feel more linear like Python/R/Julia.
  * @module transform/async
  */
 
 /**
- * Check if code contains top-level await
+ * Patterns that should be auto-awaited
+ * These are common async operations that return Promises
+ */
+const AUTO_AWAIT_PATTERNS = [
+  // Fetch API
+  /\bfetch\s*\(/g,
+  // Dynamic import
+  /\bimport\s*\(/g,
+  // Response methods
+  /\.json\s*\(/g,
+  /\.text\s*\(/g,
+  /\.blob\s*\(/g,
+  /\.arrayBuffer\s*\(/g,
+  /\.formData\s*\(/g,
+  // Common async patterns
+  /\.then\s*\(/g,
+  /\.catch\s*\(/g,
+  /\.finally\s*\(/g,
+];
+
+/**
+ * Auto-insert await before common async function calls
+ * This makes JavaScript feel more linear like Python/R
+ *
+ * @param {string} code - Source code
+ * @returns {string} Code with auto-awaits inserted
+ */
+function autoInsertAwaits(code) {
+  // Don't process if code already uses await extensively
+  // (user knows what they're doing)
+  const awaitCount = (code.match(/\bawait\b/g) || []).length;
+  const lines = code.split('\n').length;
+  if (awaitCount > lines / 2) {
+    return code;
+  }
+
+  let result = code;
+
+  // Track positions to avoid double-processing
+  // We need to be careful not to add await before already-awaited expressions
+
+  // First, temporarily replace existing awaits to protect them
+  const awaitPlaceholders = [];
+  result = result.replace(/\bawait\s+/g, (match) => {
+    const placeholder = `__AWAIT_PLACEHOLDER_${awaitPlaceholders.length}__`;
+    awaitPlaceholders.push(match);
+    return placeholder;
+  });
+
+  // Also protect strings, comments, and template literals
+  const protectedStrings = [];
+
+  // Protect comments FIRST (before strings) to handle apostrophes in comments like "doesn't"
+  result = result.replace(/\/\/[^\n]*/g, (match) => {
+    const placeholder = `__PROTECTED_${protectedStrings.length}__`;
+    protectedStrings.push(match);
+    return placeholder;
+  });
+  result = result.replace(/\/\*[\s\S]*?\*\//g, (match) => {
+    const placeholder = `__PROTECTED_${protectedStrings.length}__`;
+    protectedStrings.push(match);
+    return placeholder;
+  });
+
+  // Protect template literals
+  result = result.replace(/`(?:[^`\\]|\\.)*`/g, (match) => {
+    const placeholder = `__PROTECTED_${protectedStrings.length}__`;
+    protectedStrings.push(match);
+    return placeholder;
+  });
+
+  // Protect strings (after comments, so apostrophes in comments don't interfere)
+  result = result.replace(/"(?:[^"\\]|\\.)*"/g, (match) => {
+    const placeholder = `__PROTECTED_${protectedStrings.length}__`;
+    protectedStrings.push(match);
+    return placeholder;
+  });
+  result = result.replace(/'(?:[^'\\]|\\.)*'/g, (match) => {
+    const placeholder = `__PROTECTED_${protectedStrings.length}__`;
+    protectedStrings.push(match);
+    return placeholder;
+  });
+
+  // Now auto-insert awaits for common patterns
+  // fetch(...) -> await fetch(...)
+  result = result.replace(/\bfetch\s*\(/g, 'await fetch(');
+
+  // import(...) -> await import(...)
+  // But not "import x from" statements
+  result = result.replace(/(?<![.\w])import\s*\(/g, 'await import(');
+
+  // .json() .text() .blob() etc on response objects
+  // These methods also return Promises, so we need to await both:
+  // response.json() -> await (await response).json()
+  result = result.replace(/([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\.\s*json\s*\(\s*\)/g, 'await (await $1).json()');
+  result = result.replace(/([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\.\s*text\s*\(\s*\)/g, 'await (await $1).text()');
+  result = result.replace(/([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\.\s*blob\s*\(\s*\)/g, 'await (await $1).blob()');
+  result = result.replace(/([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\.\s*arrayBuffer\s*\(\s*\)/g, 'await (await $1).arrayBuffer()');
+  result = result.replace(/([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\.\s*formData\s*\(\s*\)/g, 'await (await $1).formData()');
+
+  // Restore protected content
+  for (let i = protectedStrings.length - 1; i >= 0; i--) {
+    result = result.replace(`__PROTECTED_${i}__`, protectedStrings[i]);
+  }
+
+  // Restore existing awaits
+  for (let i = awaitPlaceholders.length - 1; i >= 0; i--) {
+    result = result.replace(`__AWAIT_PLACEHOLDER_${i}__`, awaitPlaceholders[i]);
+  }
+
+  // Clean up any double awaits we might have introduced
+  result = result.replace(/\bawait\s+await\b/g, 'await');
+
+  return result;
+}
+
+/**
+ * Check if code contains top-level await (or will after auto-insertion)
  * @param {string} code
  * @returns {boolean}
  */
@@ -15,16 +133,17 @@ function hasTopLevelAwait(code) {
   // This is a heuristic; a proper check would need AST parsing
 
   // Remove strings, comments, and regex to avoid false positives
+  // IMPORTANT: Remove comments FIRST to handle apostrophes in comments like "doesn't"
   const cleaned = code
-    // Remove template literals (simple version)
-    .replace(/`[^`]*`/g, '')
-    // Remove strings
-    .replace(/"(?:[^"\\]|\\.)*"/g, '')
-    .replace(/'(?:[^'\\]|\\.)*'/g, '')
-    // Remove single-line comments
+    // Remove single-line comments FIRST (before strings)
     .replace(/\/\/[^\n]*/g, '')
     // Remove multi-line comments
-    .replace(/\/\*[\s\S]*?\*\//g, '');
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    // Remove template literals
+    .replace(/`[^`]*`/g, '')
+    // Remove strings (after comments, so apostrophes in comments don't interfere)
+    .replace(/"(?:[^"\\]|\\.)*"/g, '')
+    .replace(/'(?:[^'\\]|\\.)*'/g, '');
 
   // Track nesting depth of async contexts
   // This is simplified - real implementation would use AST
@@ -108,19 +227,50 @@ ${code}
  * @returns {string} Wrapped code that returns last expression
  */
 export function wrapWithLastExpression(code) {
-  const needsAsync = hasTopLevelAwait(code);
+  // Auto-insert awaits for common async patterns (fetch, import, .json(), etc.)
+  // This makes JavaScript feel more linear like Python/R/Julia
+  const autoAwaitedCode = autoInsertAwaits(code);
+
+  // Check if code needs async (either explicit await or auto-inserted)
+  const needsAsync = hasTopLevelAwait(autoAwaitedCode);
+
+  if (needsAsync) {
+    // For code with await, wrap in async IIFE
+    // This allows await to work at the "top level" of the user's code
+    const asyncWrappedCode = `(async () => {\n${autoAwaitedCode}\n})()`;
+
+    // Now wrap to capture the result
+    // Use indirect eval (0, eval)() to run in global scope so var declarations persist
+    const wrapped = `
+;(async function() {
+  let __result__;
+  try {
+    __result__ = await (0, eval)(${JSON.stringify(asyncWrappedCode)});
+  } catch (e) {
+    if (e instanceof SyntaxError) {
+      await (0, eval)(${JSON.stringify(asyncWrappedCode)});
+      __result__ = undefined;
+    } else {
+      throw e;
+    }
+  }
+  return __result__;
+})()`;
+    return wrapped.trim();
+  }
 
-  // Find the last expression and make it a return value
-  // This is tricky without AST - we use eval trick instead
+  // No async needed - use simpler synchronous wrapper
+  // Use indirect eval (0, eval)() to run in global scope so var declarations persist
+  // Note: Still use autoAwaitedCode in case auto-awaits were added but hasTopLevelAwait missed them
   const wrapped = `
-;(${needsAsync ? 'async ' : ''}function() {
+;(function() {
   let __result__;
   try {
-    __result__ = eval(${JSON.stringify(code)});
+    __result__ = (0, eval)(${JSON.stringify(autoAwaitedCode)});
   } catch (e) {
     if (e instanceof SyntaxError) {
       // Code might be statements, not expression
-      eval(${JSON.stringify(code)});
+      (0, eval)(${JSON.stringify(autoAwaitedCode)});
       __result__ = undefined;
     } else {
       throw e;

package/src/transform/persistence.js

@@ -122,12 +122,12 @@ export function transformForPersistence(code) {
 
     // Check for const/let keywords
     if (isWordBoundary(code, i)) {
-      if (code.slice(i, i + 5) === 'const' && isWordBoundary(code, i + 5)) {
+      if (code.slice(i, i + 5) === 'const' && isWordBoundaryAfter(code, i + 5)) {
         result += 'var';
         i += 5;
         continue;
       }
-      if (code.slice(i, i + 3) === 'let' && isWordBoundary(code, i + 3)) {
+      if (code.slice(i, i + 3) === 'let' && isWordBoundaryAfter(code, i + 3)) {
         result += 'var';
         i += 3;
         continue;