@opencode/codemode 0.0.0-dev-19437 → 0.0.0-dev-19439

package/dist/interpreter/runtime.js

@@ -107,6 +107,55 @@ const collectPatternNames = (pattern, out = []) => {
     }
     return out;
 };
+// `var` names declared anywhere in a function body except inside nested functions, which own theirs.
+// Memoized per body: a function's var names never change, and hoisting runs on every call.
+const varNames = new WeakMap();
+const collectVarNames = (node, out = []) => {
+    if (!node)
+        return out;
+    switch (node.type) {
+        case "VariableDeclaration":
+            if (node.kind === "var")
+                for (const declaration of node.declarations)
+                    collectPatternNames(declaration.id, out);
+            break;
+        case "BlockStatement":
+            for (const statement of node.body)
+                collectVarNames(statement, out);
+            break;
+        case "IfStatement":
+            collectVarNames(node.consequent, out);
+            collectVarNames(node.alternate, out);
+            break;
+        case "ForStatement":
+            if (node.init?.type === "VariableDeclaration")
+                collectVarNames(node.init, out);
+            collectVarNames(node.body, out);
+            break;
+        case "ForInStatement":
+        case "ForOfStatement":
+            if (node.left.type === "VariableDeclaration")
+                collectVarNames(node.left, out);
+            collectVarNames(node.body, out);
+            break;
+        case "WhileStatement":
+        case "DoWhileStatement":
+        case "LabeledStatement":
+            collectVarNames(node.body, out);
+            break;
+        case "SwitchStatement":
+            for (const item of node.cases)
+                for (const statement of item.consequent)
+                    collectVarNames(statement, out);
+            break;
+        case "TryStatement":
+            collectVarNames(node.block, out);
+            collectVarNames(node.handler?.body, out);
+            collectVarNames(node.finalizer, out);
+            break;
+    }
+    return out;
+};
 const loopDeclaration = (left, statement) => {
     if (left.type !== "VariableDeclaration")
         return undefined;
@@ -183,6 +232,7 @@ class Frame {
         return Effect.gen(function* () {
             self.predeclareLexical(program.body);
             self.hoistFunctions(program.body);
+            self.hoistVars(program.body);
             let value = undefined;
             for (const [index, statement] of program.body.entries()) {
                 if (index === program.body.length - 1 && statement.type === "ExpressionStatement") {
@@ -290,6 +340,19 @@ class Frame {
             this.scopes.declare(node.id.name, this.createFunction(node), true, node);
         }
     }
+    // Hoisted `var` bindings start undefined, or copy a same-named parameter. Function bodies hoist
+    // into their own scope above the parameters so closures in parameter defaults keep seeing outer names.
+    hoistVars(statements, parameters) {
+        const names = varNames.get(statements) ??
+            statements.reduce((out, statement) => collectVarNames(statement, out), []);
+        varNames.set(statements, names);
+        const scope = this.scopes.current();
+        for (const name of names) {
+            if (scope.has(name))
+                continue;
+            scope.set(name, { mutable: true, value: parameters?.get(name)?.value, initialized: true });
+        }
+    }
     predeclareLexical(statements) {
         for (const statement of statements) {
             if (statement.type !== "VariableDeclaration")
@@ -325,7 +388,9 @@ class Frame {
             self.scopes.push();
             return yield* Effect.gen(function* () {
                 const cases = node.cases;
-                self.predeclareLexical(cases.flatMap((branch) => branch.consequent));
+                const statements = cases.flatMap((branch) => branch.consequent);
+                self.predeclareLexical(statements);
+                self.hoistFunctions(statements);
                 let defaultIndex;
                 let selected;
                 for (const [index, branch] of cases.entries()) {
@@ -451,18 +516,20 @@ class Frame {
             }
             const assignment = left.type === "VariableDeclaration" ? undefined : left;
             const evaluateBody = (value) => Effect.gen(function* () {
-                if (declared) {
+                if (declared?.lexical) {
                     self.scopes.push();
-                    if (declared.lexical)
-                        self.predeclarePattern(declared.pattern, declared.mutable, left);
-                    yield* self.declarePattern(declared.pattern, value, declared.mutable, left, declared.lexical);
+                    self.predeclarePattern(declared.pattern, declared.mutable, left);
+                    yield* self.declarePattern(declared.pattern, value, declared.mutable, left, true);
+                }
+                else if (declared) {
+                    yield* self.assignPattern(declared.pattern, value, left);
                 }
                 else if (assignment) {
                     yield* self.assignPattern(assignment, value, left);
                 }
                 return yield* self.evaluateStatement(node.body);
             }).pipe(Effect.ensuring(Effect.sync(() => {
-                if (declared)
+                if (declared?.lexical)
                     self.scopes.pop();
             })));
             while (true) {
@@ -662,18 +729,20 @@ class Frame {
             const assignmentName = left.type === "Identifier" ? left.name : undefined;
             for (const key of keys) {
                 const result = yield* Effect.gen(function* () {
-                    if (declared) {
+                    if (declared?.lexical) {
                         self.scopes.push();
-                        if (declared.lexical)
-                            self.predeclarePattern(declared.pattern, declared.mutable, left);
-                        yield* self.declarePattern(declared.pattern, key, declared.mutable, left, declared.lexical);
+                        self.predeclarePattern(declared.pattern, declared.mutable, left);
+                        yield* self.declarePattern(declared.pattern, key, declared.mutable, left, true);
+                    }
+                    else if (declared) {
+                        yield* self.assignPattern(declared.pattern, key, left);
                     }
                     else if (assignmentName) {
                         self.scopes.set(assignmentName, key, left);
                     }
                     return yield* self.evaluateStatement(node.body);
                 }).pipe(Effect.ensuring(Effect.sync(() => {
-                    if (declared)
+                    if (declared?.lexical)
                         self.scopes.pop();
                 })));
                 const exit = loopExit(result, labels);
@@ -759,8 +828,14 @@ class Frame {
                     throw new InterpreterRuntimeError("Unsupported variable declaration shape.", declaration);
                 }
                 const init = declaration.init;
+                // `var x` alone is a no-op: the binding was hoisted on function entry.
+                if (kind === "var") {
+                    if (init)
+                        yield* self.assignPattern(declaration.id, yield* self.evaluateExpression(init), declaration);
+                    continue;
+                }
                 const value = init ? yield* self.evaluateExpression(init) : undefined;
-                yield* self.declarePattern(declaration.id, value, kind !== "const", declaration, kind !== "var");
+                yield* self.declarePattern(declaration.id, value, kind !== "const", declaration, true);
             }
         });
     }
@@ -1318,6 +1393,8 @@ class Frame {
                 yield* invocation.declarePattern(parameter, args[index], true, parameter, true);
             }
             if (fn.body.type === "BlockStatement") {
+                invocation.scopes.push();
+                invocation.hoistVars(fn.body.body, paramScope);
                 const result = yield* invocation.evaluateStatement(fn.body);
                 return result.kind === "return" ? result.value : undefined;
             }
@@ -1327,12 +1404,7 @@ class Frame {
             return Effect.succeed(this.createGenerator(invocation, run, fn.async));
         if (!fn.async)
             return run;
-        // The initial yield assigns the promise before the body can self-resolve.
-        const box = {};
-        return Effect.map(this.createPromise(Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runtime.runner, value, fn.body, box))), (promise) => {
-            box.promise = promise;
-            return promise;
-        });
+        return this.runtime.promises.createWithSelf((self) => Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runtime.runner, value, fn.body, self)));
     }
     createGenerator(invocation, run, asynchronous) {
         const state = { started: false, completed: false, draining: false, pending: [], pendingIndex: 0 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "0.0.0-dev-19437",
+  "version": "0.0.0-dev-19439",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",