mustardscript 0.1.3 → 0.2.1

package/README.md

@@ -38,9 +38,9 @@ The current implementation already supports:
 - `Map` and `Set` with supported iterable constructors, SameValueZero key and
   membership semantics, insertion-order-preserving storage, and iterator
   helpers
-- `async` functions, `await`, guest promises, `new Promise(...)`, Promise
-  combinators and instance methods, basic thenable adoption, and internal
-  microtask scheduling for the supported subset
+- `async` functions, top-level `await`, guest promises, `new Promise(...)`,
+  Promise combinators and instance methods, basic thenable adoption, and
+  internal microtask scheduling for the supported subset
 - guest-internal `BigInt` literals with exact-integer arithmetic,
   comparison, keyed-collection membership, and string/property-key coercion
 - conservative array, string, object, and Math helper methods, including
@@ -348,7 +348,7 @@ JavaScript.
 - Arrays, plain objects, `Map`, and `Set`
 - `let` and `const`
 - Functions and closures
-- `async` functions and `await`
+- `async` functions and `await`, including top-level `await`
 - Arrow functions
 - `if`, `switch`, loops, `break`, and `continue`
 - `throw`, `try`, `catch`, and `finally`
@@ -432,7 +432,7 @@ Currently implemented built-ins:
 
 Current Promise support is intentionally narrow:
 
-- async functions return internal guest promises
+- async functions and top-level `await` return through internal guest promises
 - `new Promise(executor)` is supported when `executor` is callable and
   completes synchronously from the runtime's perspective
 - `Promise.resolve(...)`, `Promise.reject(...)`, `Promise.all(...)`,
@@ -807,6 +807,20 @@ inside the supported language subset, and lowers to an executable compiled
 program. It does not prove that a later `run()` or `start()` call will succeed
 with a particular host policy, input set, capability map, or runtime limit.
 
+For LLM-generated snippets, hosts can opt into a narrow compile-time
+compatibility mode:
+
+```ts
+const program = new Mustard('const value = 41; return value + 1;', {
+  lenientMode: true,
+})
+```
+
+`lenientMode` only accepts a `return` when it is the final top-level statement;
+that statement is treated like MustardScript's normal final expression result.
+Nested top-level returns, non-final top-level returns, and all forbidden forms
+still fail closed. Strict behavior remains the default.
+
 `Progress.load(...)` always requires explicit restore authority: the host must
 pass either a reusable `ExecutionContext` or explicit `capabilities` /
 `console`, explicit `limits` as an object (use `{}` for default runtime

package/dist/lib/runtime.js

@@ -28,7 +28,24 @@ function createMustardClass({ native, materializeStep, parseStep }) {
         })
       : null;
 
-  function compileProgram(code) {
+  function compileOptionsJson(options = {}) {
+    if (options === null || typeof options !== 'object' || Array.isArray(options)) {
+      throw new TypeError('compile options must be a plain object');
+    }
+    if (options.lenientMode === undefined || options.lenientMode === false) {
+      return null;
+    }
+    if (options.lenientMode !== true) {
+      throw new TypeError('options.lenientMode must be a boolean');
+    }
+    return '{"lenient_mode":true}';
+  }
+
+  function compileProgram(code, options = {}) {
+    const optionsJson = compileOptionsJson(options);
+    if (optionsJson !== null) {
+      return callNative(native.compileProgramWithOptions, code, optionsJson);
+    }
     return callNative(native.compileProgram, code);
   }
 
@@ -38,15 +55,15 @@ function createMustardClass({ native, materializeStep, parseStep }) {
 
   return class Mustard {
     constructor(code, options = {}) {
-      this._programHandle = compileProgram(code);
+      this._programHandle = compileProgram(code, options);
       this._program = null;
       this._inputNames = options.inputs ?? [];
       this._programHandleToken = {};
       programHandleRegistry?.register(this, this._programHandle, this._programHandleToken);
     }
 
-    static validateProgram(code) {
-      const programHandle = compileProgram(code);
+    static validateProgram(code, options = {}) {
+      const programHandle = compileProgram(code, options);
       releaseProgram(programHandle);
     }
 

package/index.d.ts

@@ -4,6 +4,8 @@ export declare function cancelCancellationToken(tokenId: string): void
 
 export declare function compileProgram(source: string): string
 
+export declare function compileProgramWithOptions(source: string, optionsJson: string): string
+
 export declare function createCancellationToken(): string
 
 export declare function createExecutionContext(policyJson: string): string

package/mustard.d.ts

@@ -24,6 +24,7 @@ export interface ConsoleCallbacks {
 
 export interface CompileOptions {
   inputs?: string[];
+  lenientMode?: boolean;
 }
 
 export type SnapshotKey = string | Buffer | Uint8Array;
@@ -203,7 +204,7 @@ export class Mustard {
   start(options?: ExecutionOptions): StructuredValue | Progress;
   dump(): Buffer;
 
-  static validateProgram(code: string): void;
+  static validateProgram(code: string, options?: CompileOptions): void;
   static load(buffer: Buffer): Mustard;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mustardscript",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Sandboxed, subset JavaScript runtime for Node services.",
   "main": "dist/index.js",
   "types": "mustard.d.ts",
@@ -28,10 +28,10 @@
     ]
   },
   "optionalDependencies": {
-    "@mustardscript/binding-darwin-arm64": "0.1.3",
-    "@mustardscript/binding-darwin-x64": "0.1.3",
-    "@mustardscript/binding-linux-x64-gnu": "0.1.3",
-    "@mustardscript/binding-win32-x64-msvc": "0.1.3"
+    "@mustardscript/binding-darwin-arm64": "0.2.1",
+    "@mustardscript/binding-darwin-x64": "0.2.1",
+    "@mustardscript/binding-linux-x64-gnu": "0.2.1",
+    "@mustardscript/binding-win32-x64-msvc": "0.2.1"
   },
   "scripts": {
     "prepack": "node scripts/build-ts-dist.ts",