@opencode/codemode 2.0.13 → 2.0.15

package/dist/interpreter/interpreter.d.ts

@@ -1,9 +1,9 @@
-import type { Program } from "acorn";
+import type { Program, TaggedTemplateExpression } from "acorn";
 import { Effect } from "effect";
 import { type Json } from "../data.js";
 import { type ToolRuntime } from "../tool-runtime.js";
 import { type Builtins } from "./intrinsics.js";
-import { type Cursor, PromiseObj, type Value } from "./objects.js";
+import { type Cursor, Arr, PromiseObj, type Value } from "./objects.js";
 import { Pending } from "./promises.js";
 /** One program execution: the tool bridge, promise scheduler, captured logs, and the global scope built once. */
 export declare class Interpreter<R> {
@@ -11,6 +11,8 @@ export declare class Interpreter<R> {
     readonly pending: Pending<R>;
     readonly builtins: Builtins;
     readonly logs: Array<string>;
+    /** Template objects by site: a tag sees the same `strings` array every time its literal is evaluated, as in JS. */
+    readonly templates: WeakMap<TaggedTemplateExpression, Arr>;
     private readonly root;
     constructor(options: {
         readonly tools: ToolRuntime<R>;

package/dist/interpreter/interpreter.js

@@ -6,7 +6,7 @@ import { checkStringLength } from "./limits.js";
 import { locate, materialize } from "./errors.js";
 import { primitivePrototype } from "./intrinsics.js";
 import { globals } from "./globals.js";
-import { assign, Callable, define, get, hostCursor, IteratorObj, has, hidden, hasPrototype, keys, Native, parseArrayIndex, Arr, Fn, GeneratorObj, Obj, PromiseObj, record, remove, set, coerceToNumber, coerceToString, } from "./objects.js";
+import { assign, Callable, define, frozen, get, hostCursor, IteratorObj, has, hidden, hasPrototype, keys, Native, parseArrayIndex, Arr, Fn, GeneratorObj, Obj, PromiseObj, record, remove, set, coerceToNumber, coerceToString, } from "./objects.js";
 import { preserveConsumerError } from "./callback.js";
 import { Pending, resolvePromise, resolvePromiseValue } from "./promises.js";
 import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue } from "./references.js";
@@ -163,6 +163,8 @@ export class Interpreter {
     pending;
     builtins;
     logs;
+    /** Template objects by site: a tag sees the same `strings` array every time its literal is evaluated, as in JS. */
+    templates = new WeakMap();
     root;
     constructor(options) {
         this.tools = options.tools;
@@ -715,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) {
@@ -729,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(() => {
@@ -1016,6 +1018,8 @@ class Frame {
                 return this.evaluateArrayExpression(node);
             case "TemplateLiteral":
                 return this.evaluateTemplateLiteral(node);
+            case "TaggedTemplateExpression":
+                return this.evaluateTaggedTemplate(node);
             case "ConditionalExpression":
                 return this.evaluateConditionalExpression(node);
             case "UpdateExpression":
@@ -1366,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);
                 }
             });
@@ -1666,7 +1674,7 @@ class Frame {
         return Effect.gen(function* () {
             for (let index = 0; index < quasis.length; index += 1) {
                 const quasi = quasis[index];
-                // acorn only omits `cooked` for invalid escapes in tagged templates, which are unsupported.
+                // acorn only omits `cooked` for invalid escapes, which are a parse error outside a tagged template.
                 if (typeof quasi.value.cooked !== "string") {
                     throw typeError("Invalid template literal quasi.", quasi);
                 }
@@ -1681,6 +1689,27 @@ class Frame {
             return output;
         });
     }
+    // `tag\`a${x}b\`` is `tag(strings, x)`: the tag is read like a callee (a member keeps its receiver), the
+    // substitutions are evaluated in order, and `strings` carries the escaped source as `strings.raw`.
+    evaluateTaggedTemplate(node) {
+        const self = this;
+        return Effect.gen(function* () {
+            const { callable, thisValue } = node.tag.type === "MemberExpression"
+                ? yield* self.readMethod(node.tag)
+                : { callable: yield* self.evaluateExpression(node.tag), thisValue: undefined };
+            const strings = self.ctx.templates.get(node) ?? self.createTemplateObject(node);
+            const values = yield* Effect.forEach(node.quasi.expressions, (expression) => self.evaluateExpression(expression));
+            return yield* self.call(callable, thisValue, [strings, ...values], node, node.tag);
+        });
+    }
+    createTemplateObject(node) {
+        const array = this.ctx.builtins.Array;
+        // An invalid escape such as `\unicode` cooks to `undefined` and survives only in `raw`.
+        const strings = new Arr(array, node.quasi.quasis.map((quasi) => quasi.value.cooked ?? undefined));
+        define(strings, "raw", new Arr(array, node.quasi.quasis.map((quasi) => quasi.value.raw)), frozen);
+        this.ctx.templates.set(node, strings);
+        return strings;
+    }
     evaluateConditionalExpression(node) {
         return Effect.flatMap(this.evaluateExpression(node.test), (test) => this.evaluateExpression(test ? node.consequent : node.alternate));
     }

package/dist/interpreter/model.d.ts

@@ -62,7 +62,7 @@ export declare const rangeError: (message: string, node?: AstNode) => PendingThr
 export declare const referenceError: (message: string, node?: AstNode) => PendingThrow;
 export declare const syntaxError: (message: string, node?: AstNode) => PendingThrow;
 export declare const uriError: (message: string, node?: AstNode) => PendingThrow;
-export declare const supportedSyntaxMessage = "This is a restricted JavaScript-like language. Supported: plain and async functions, data literals, destructuring, standard control flow, await and Promise, and built-ins such as Array, Object, Math, JSON, Date, RegExp, Map, Set, and URL. Unsupported: classes, this, getters/setters, tagged templates, BigInt, and custom Symbols. Use plain functions and data objects instead.";
+export declare const supportedSyntaxMessage = "This is a restricted JavaScript-like language. Supported: plain and async functions, data literals, destructuring, standard control flow, await and Promise, and built-ins such as Array, Object, Math, JSON, Date, RegExp, Map, Set, and URL. Unsupported: classes, this, getters/setters, BigInt, and custom Symbols. Use plain functions and data objects instead.";
 export declare const unsupportedSyntax: (kind: string, node: AstNode) => PendingThrow;
 export declare const sourceLocation: (node: AstNode) => {
     readonly line: number;

package/dist/interpreter/model.js

@@ -49,7 +49,7 @@ export const referenceError = failure("ReferenceError");
 export const syntaxError = failure("SyntaxError");
 export const uriError = failure("URIError");
 // Orient the agent rather than enumerate JavaScript; interpreter-support.md is the full matrix.
-export const supportedSyntaxMessage = "This is a restricted JavaScript-like language. Supported: plain and async functions, data literals, destructuring, standard control flow, await and Promise, and built-ins such as Array, Object, Math, JSON, Date, RegExp, Map, Set, and URL. Unsupported: classes, this, getters/setters, tagged templates, BigInt, and custom Symbols. Use plain functions and data objects instead.";
+export const supportedSyntaxMessage = "This is a restricted JavaScript-like language. Supported: plain and async functions, data literals, destructuring, standard control flow, await and Promise, and built-ins such as Array, Object, Math, JSON, Date, RegExp, Map, Set, and URL. Unsupported: classes, this, getters/setters, BigInt, and custom Symbols. Use plain functions and data objects instead.";
 export const unsupportedSyntax = (kind, node) => new PendingThrow("SyntaxError", `Syntax '${kind}' is not supported. ${supportedSyntaxMessage}`, node, "UnsupportedSyntax", [supportedSyntaxMessage]);
 // Acorn lines are 1-based and its columns are 0-based. Diagnostics use 1-based columns of the submitted source.
 export const sourceLocation = (node) => ({

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/dist/stdlib/string.js

@@ -2,9 +2,9 @@ import { Effect } from "effect";
 import { constructor, fn, methods } from "../interpreter/native.js";
 import { checkArrayLength, checkStringLength } from "../interpreter/limits.js";
 import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js";
-import { define, hidden, Arr, hostIterator, RegExpObj, record, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
+import { define, get, hidden, Arr, hostIterator, Obj, RegExpObj, record, coerceToInteger, coerceToNumber, coerceToString, } from "../interpreter/objects.js";
 import { containsOpaqueReference, typeofValue } from "../interpreter/references.js";
-import { applyCollectionCallback, isSupportedCallback } from "../interpreter/callback.js";
+import { applyCollectionCallback, isSupportedCallback, toPrimitiveString } from "../interpreter/callback.js";
 import { matchToValue, toHostRegex } from "./regexp.js";
 import { coercion } from "./value.js";
 // console is intercepted by the interpreter before reaching here.
@@ -78,6 +78,25 @@ export const stringGlobal = (ctx) => {
     methods(builtins, string, [
         codeUnits("fromCharCode", String.fromCharCode),
         codeUnits("fromCodePoint", String.fromCodePoint),
+        [
+            "raw",
+            1,
+            (_, args) => {
+                const template = args[0];
+                const raw = template instanceof Obj ? get(template, "raw") : undefined;
+                if (!(raw instanceof Obj))
+                    throw typeError("String.raw expects a template object with a raw array.");
+                const count = Math.max(0, coerceToInteger(get(raw, "length")));
+                checkArrayLength(count);
+                // Each literal is followed by its substitution, except the last literal, or when substitutions run out.
+                const parts = Array.from({ length: count }, (_, index) => index + 1 < count && index + 1 < args.length ? [get(raw, index), args[index + 1]] : [get(raw, index)]).flat();
+                return Effect.map(Effect.forEach(parts, (part) => toPrimitiveString(ctx, part)), (strings) => {
+                    const output = strings.join("");
+                    checkStringLength(output.length);
+                    return output;
+                });
+            },
+        ],
     ]);
     const self = (thisValue, name) => {
         if (typeof thisValue === "string")

package/package.json

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