@opencode/codemode 0.0.0-dev-20032 → 0.0.0-dev-20035

package/dist/interpreter/interpreter.js

@@ -717,10 +717,10 @@ class Frame {
                 self.predeclarePattern(declared.pattern, declared.mutable, left);
             const right = yield* self.evaluateExpression(node.right);
             const keys = self.enumerableKeys(right, node.right);
-            if (left.type !== "Identifier" && left.type !== "VariableDeclaration") {
+            if (left.type === "RestElement" || left.type === "AssignmentPattern") {
                 throw typeError("Unsupported for...in binding.", left);
             }
-            const assignmentName = left.type === "Identifier" ? left.name : undefined;
+            const assignment = left.type === "VariableDeclaration" ? undefined : left;
             for (const key of keys) {
                 const result = yield* Effect.gen(function* () {
                     if (declared?.lexical) {
@@ -731,8 +731,8 @@ class Frame {
                     else if (declared) {
                         yield* self.assignPattern(declared.pattern, key, left);
                     }
-                    else if (assignmentName) {
-                        self.scopes.set(assignmentName, key, left);
+                    else if (assignment) {
+                        yield* self.assignPattern(assignment, key, left);
                     }
                     return yield* self.evaluateStatement(node.body);
                 }).pipe(Effect.ensuring(Effect.sync(() => {
@@ -1370,12 +1370,16 @@ class Frame {
                     paramScope.set(name, { mutable: true, value: undefined, initialized: false });
                 }
             }
+            const parameters = fn.parameters.map((parameter) => parameter.type === "Identifier" ? parameter.name : undefined);
             const bind = Effect.gen(function* () {
                 for (const [index, parameter] of fn.parameters.entries()) {
                     if (parameter.type === "RestElement") {
                         yield* invocation.declarePattern(parameter.argument, new Arr(self.ctx.builtins.Array, args.slice(index)), true, parameter, true);
                         break;
                     }
+                    // A sloppy simple parameter list may repeat a name; the last occurrence wins, as in JS.
+                    if (parameter.type === "Identifier" && parameters.lastIndexOf(parameter.name) !== index)
+                        continue;
                     yield* invocation.declarePattern(parameter, args[index], true, parameter, true);
                 }
             });

package/dist/stdlib/regexp.js

@@ -15,20 +15,16 @@ const flagProperties = [
 const regexFailureReason = (error) => (error instanceof Error ? error.message : String(error)).replace(/^Invalid regular expression:\s*/i, "");
 const escapeRegexHint = 'To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. "\\\\(") or test for them with String.includes instead.';
 export const toHostRegex = (arg, method, extraFlags = "") => {
-    // Native parity: an undefined pattern behaves as an empty pattern.
-    if (arg === undefined)
-        return new RegExp("", extraFlags);
     if (arg instanceof RegExpObj)
         return arg.regex;
-    if (typeof arg === "string") {
-        try {
-            return new RegExp(arg, extraFlags);
-        }
-        catch (error) {
-            throw syntaxError(`String.${method} received the string ${JSON.stringify(arg)}, which is not a valid regular expression pattern (${regexFailureReason(error)}). ${escapeRegexHint}`);
-        }
+    // Anything else is a pattern string, as `new RegExp(arg)` would read it: undefined is the empty pattern.
+    const source = arg === undefined ? "" : coerceToString(arg);
+    try {
+        return new RegExp(source, extraFlags);
+    }
+    catch (error) {
+        throw syntaxError(`String.${method} received the string ${JSON.stringify(source)}, which is not a valid regular expression pattern (${regexFailureReason(error)}). ${escapeRegexHint}`);
     }
-    throw typeError(`String.${method} expects a regular expression (a /pattern/flags literal or new RegExp(...)) or a string pattern, not ${arg === null ? "null" : typeof arg}.`);
 };
 export const matchToValue = (builtins, match) => {
     const result = new Arr(builtins.Array, Array.from(match, (group) => group));

package/package.json

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