@opencode/codemode 0.0.0-dev-19438 → 0.0.0-dev-19440

package/dist/interpreter/globals.js

@@ -11,6 +11,7 @@ import { regexpGlobal } from "../stdlib/regexp.js";
 import { stringGlobal } from "../stdlib/string.js";
 import { uriGlobal, urlGlobal, urlSearchParamsGlobal } from "../stdlib/url.js";
 import { coercion, errorConstructors } from "../stdlib/value.js";
+import { atobGlobal, btoaGlobal, cryptoGlobal } from "../stdlib/web.js";
 import { ToolReference } from "../tool-runtime.js";
 import { errorGlobal } from "./errors.js";
 import { HostFunction } from "./host.js";
@@ -55,5 +56,8 @@ export const globals = (host) => [
     ["encodeURIComponent", uriGlobal("encodeURIComponent")],
     ["decodeURI", uriGlobal("decodeURI")],
     ["decodeURIComponent", uriGlobal("decodeURIComponent")],
+    ["atob", atobGlobal],
+    ["btoa", btoaGlobal],
+    ["crypto", cryptoGlobal],
     ...[...errorConstructors].map((name) => [name, errorGlobal(name, host.runner)]),
 ];

package/dist/interpreter/runtime.js

@@ -108,6 +108,8 @@ 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;
@@ -341,13 +343,14 @@ class Frame {
     // 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 statement of statements) {
-            for (const name of collectVarNames(statement)) {
-                if (scope.has(name))
-                    continue;
-                scope.set(name, { mutable: true, value: parameters?.get(name)?.value, initialized: true });
-            }
+        for (const name of names) {
+            if (scope.has(name))
+                continue;
+            scope.set(name, { mutable: true, value: parameters?.get(name)?.value, initialized: true });
         }
     }
     predeclareLexical(statements) {
@@ -385,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()) {
@@ -1399,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/dist/stdlib/web.d.ts

@@ -0,0 +1,4 @@
+import { HostNamespace } from "../interpreter/host.js";
+export declare const atobGlobal: import("../interpreter/host.js").HostFunction<never>;
+export declare const btoaGlobal: import("../interpreter/host.js").HostFunction<never>;
+export declare const cryptoGlobal: HostNamespace;

package/dist/stdlib/web.js

@@ -0,0 +1,21 @@
+import { HostNamespace, sync } from "../interpreter/host.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { coerceToString } from "./value.js";
+// WebIDL DOMString conversion: a missing argument is a TypeError, anything else stringifies.
+const base64 = (name) => sync(name, (args, node) => {
+    if (args.length === 0) {
+        throw new InterpreterRuntimeError(`${name} requires 1 argument, but only 0 were provided.`, node).as("TypeError");
+    }
+    const input = coerceToString(args[0]);
+    try {
+        return name === "atob" ? atob(input) : btoa(input);
+    }
+    catch {
+        throw new InterpreterRuntimeError("The string contains invalid characters.", node).as("InvalidCharacterError");
+    }
+});
+export const atobGlobal = base64("atob");
+export const btoaGlobal = base64("btoa");
+export const cryptoGlobal = new HostNamespace("crypto", {
+    randomUUID: sync("crypto.randomUUID", () => crypto.randomUUID()),
+});

package/package.json

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