@opencode/codemode 0.0.0-dev-20027 → 0.0.0-dev-20030

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;
@@ -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":
@@ -1666,7 +1670,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 +1685,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/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": "0.0.0-dev-20027",
+  "version": "0.0.0-dev-20030",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",