@opencode/codemode 0.0.0-dev-19356 → 0.0.0-dev-19360

package/dist/interpreter/execute.js

@@ -6,7 +6,7 @@ import { transpile } from "#transpile";
 import { toData } from "../data.js";
 import { ToolRuntime } from "../tool-runtime.js";
 import { normalizeError } from "./errors.js";
-import { InterpreterRuntimeError, isRecord } from "./model.js";
+import { InterpreterRuntimeError } from "./model.js";
 import { PromiseRuntime } from "./promises.js";
 import { Interpreter } from "./runtime.js";
 export const executeProgram = (code, prepared, limits, hooks) => {
@@ -88,17 +88,13 @@ const parseProgram = (code) => {
     const bodyStart = transpiled.outputText.indexOf("{") + 1;
     const bodyEnd = transpiled.outputText.lastIndexOf("}");
     const executableCode = transpiled.outputText.slice(bodyStart, bodyEnd);
-    const parsed = parse(executableCode, {
+    return parse(executableCode, {
         ecmaVersion: "latest",
         sourceType: "script",
         allowReturnOutsideFunction: true,
         allowAwaitOutsideFunction: true,
         locations: true,
     });
-    if (!isRecord(parsed) || parsed.type !== "Program" || !Array.isArray(parsed.body)) {
-        throw new InterpreterRuntimeError("Failed to parse script as a Program node.");
-    }
-    return parsed;
 };
 const utf8ByteLength = (value) => new TextEncoder().encode(value).byteLength;
 // Drop a replacement character produced by truncating inside a UTF-8 sequence.

package/dist/interpreter/model.d.ts

@@ -1,24 +1,10 @@
+import type { BlockStatement, Expression, Node, Pattern } from "acorn";
 import type { Effect } from "effect";
 import type { DiagnosticKind } from "../codemode.js";
 import type { SafeObject } from "../data.js";
 import type { Values } from "../values.js";
-export type SourcePosition = {
-    line: number;
-    column: number;
-};
-export type SourceLocation = {
-    start: SourcePosition;
-    end: SourcePosition;
-};
-export type AstNode = {
-    type: string;
-    loc?: SourceLocation;
-    [key: string]: unknown;
-};
-export type ProgramNode = AstNode & {
-    type: "Program";
-    body: Array<AstNode>;
-};
+/** Any parsed node; the interpreter narrows on `type` and reads `loc` for diagnostics. */
+export type AstNode = Node;
 export type Binding = {
     mutable: boolean;
     value: unknown;
@@ -41,12 +27,12 @@ export type MemberReference = {
     key: PropertyKey;
 };
 export declare class CodeModeFunction {
-    readonly parameters: ReadonlyArray<AstNode>;
-    readonly body: AstNode;
+    readonly parameters: ReadonlyArray<Pattern>;
+    readonly body: BlockStatement | Expression;
     readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
     readonly async: boolean;
     readonly generator: boolean;
-    constructor(parameters: ReadonlyArray<AstNode>, body: AstNode, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
+    constructor(parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
 }
 export type GeneratorRequestKind = "next" | "return" | "throw";
 export declare class CodeModeGenerator {
@@ -138,12 +124,6 @@ export declare class InterpreterRuntimeError extends Error {
 }
 export declare const unsupportedSyntax: (kind: string, node: AstNode) => InterpreterRuntimeError;
 export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
-export declare const asNode: (value: unknown, context: string) => AstNode;
-export declare const getArray: (node: AstNode, key: string) => Array<unknown>;
-export declare const getString: (node: AstNode, key: string) => string;
-export declare const getBoolean: (node: AstNode, key: string) => boolean;
-export declare const getOptionalNode: (node: AstNode, key: string) => AstNode | undefined;
-export declare const getNode: (node: AstNode, key: string) => AstNode;
 export declare const sourceLocation: (node: AstNode) => {
     readonly line: number;
     readonly column: number;

package/dist/interpreter/model.js

@@ -143,37 +143,6 @@ export class InterpreterRuntimeError extends Error {
 }
 export const unsupportedSyntax = (kind, node) => new InterpreterRuntimeError(`Syntax '${kind}' is not supported. ${supportedSyntaxMessage}`, node, "UnsupportedSyntax", [supportedSyntaxMessage]);
 export const isRecord = (value) => typeof value === "object" && value !== null;
-export const asNode = (value, context) => {
-    if (!isRecord(value) || typeof value.type !== "string") {
-        throw new InterpreterRuntimeError(`Invalid AST node while reading ${context}.`);
-    }
-    return value;
-};
-export const getArray = (node, key) => {
-    const value = node[key];
-    if (!Array.isArray(value))
-        throw new InterpreterRuntimeError(`Expected '${key}' to be an array.`, node);
-    return value;
-};
-export const getString = (node, key) => {
-    const value = node[key];
-    if (typeof value !== "string")
-        throw new InterpreterRuntimeError(`Expected '${key}' to be a string.`, node);
-    return value;
-};
-export const getBoolean = (node, key) => {
-    const value = node[key];
-    if (typeof value !== "boolean")
-        throw new InterpreterRuntimeError(`Expected '${key}' to be a boolean.`, node);
-    return value;
-};
-export const getOptionalNode = (node, key) => {
-    const value = node[key];
-    if (value === undefined || value === null)
-        return undefined;
-    return asNode(value, key);
-};
-export const getNode = (node, key) => asNode(node[key], key);
 export const sourceLocation = (node) => ({
     line: Math.max(1, (node.loc?.start.line ?? 2) - 1),
     column: Math.max(1, (node.loc?.start.column ?? 4) - 3),

package/dist/interpreter/runtime.d.ts

@@ -1,5 +1,5 @@
+import type { Program } from "acorn";
 import { Effect } from "effect";
-import { type ProgramNode } from "./model.js";
 import { PromiseRuntime } from "./promises.js";
 export declare class Interpreter<R> {
     private scopes;
@@ -12,7 +12,7 @@ export declare class Interpreter<R> {
     private generatorAsync;
     private readonly runner;
     constructor(executeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, invokeSearch: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>, promises: PromiseRuntime<R>, logs?: Array<string>);
-    run(program: ProgramNode): Effect.Effect<unknown, unknown, R>;
+    run(program: Program): Effect.Effect<unknown, unknown, R>;
     private createToolCallPromise;
     private createPromise;
     private settlePromise;

package/dist/interpreter/runtime.js

@@ -1,7 +1,7 @@
 import { Cause, Deferred, Effect, Exit } from "effect";
 import { isBlockedMember, ToolRuntimeError, toProgram } from "../data.js";
 import { ToolReference } from "../tool-runtime.js";
-import { AsyncIteratorSymbol, asNode, CodeModeFunction, CodeModeGenerator, CoercionFunction, ComputedValue, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, GeneratorMethodReference, GeneratorReturn, getArray, getBoolean, getNode, getOptionalNode, getString, IntrinsicReference, InterpreterRuntimeError, isRecord, IteratorSymbol, IteratorSymbols, JsonMethodReference, OptionalShortCircuit, PromiseCapabilityFunction, PromiseInstanceMethodReference, PromiseMethodReference, PromiseNamespace, ProgramThrow, SearchFunction, SymbolNamespace, unsupportedSyntax, UriFunction, } from "./model.js";
+import { AsyncIteratorSymbol, CodeModeFunction, CodeModeGenerator, CoercionFunction, ComputedValue, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, GeneratorMethodReference, GeneratorReturn, IntrinsicReference, InterpreterRuntimeError, isRecord, IteratorSymbol, IteratorSymbols, JsonMethodReference, OptionalShortCircuit, PromiseCapabilityFunction, PromiseInstanceMethodReference, PromiseMethodReference, PromiseNamespace, ProgramThrow, SearchFunction, SymbolNamespace, unsupportedSyntax, UriFunction, } from "./model.js";
 import { caughtErrorValue, constructAggregateErrorValue, constructErrorValue } from "./errors.js";
 import { arrayStatics, invokeArrayFrom, invokeGlobalMethod, invokeGroupBy, invokeIntrinsic, toPrimitive, } from "./methods.js";
 import { preserveConsumerError } from "./iterator.js";
@@ -40,18 +40,18 @@ const parseArrayIndex = (key) => {
     return index < MAX_ARRAY_LENGTH ? index : undefined;
 };
 const calleeDescription = (callee) => {
-    if (callee.type === "Identifier")
-        return getString(callee, "name");
-    if (callee.type === "MemberExpression") {
-        const object = getNode(callee, "object");
-        const property = getNode(callee, "property");
-        const key = callee.computed !== true && property.type === "Identifier"
-            ? getString(property, "name")
+    if (callee?.type === "Identifier")
+        return callee.name;
+    if (callee?.type === "MemberExpression") {
+        const object = callee.object;
+        const property = callee.property;
+        const key = !callee.computed && property.type === "Identifier"
+            ? property.name
             : property.type === "Literal" && typeof property.value === "string"
                 ? property.value
                 : undefined;
         if (object.type === "Identifier" && key !== undefined)
-            return `${getString(object, "name")}.${key}`;
+            return `${object.name}.${key}`;
     }
     return "The called value";
 };
@@ -90,24 +90,23 @@ const instanceofValue = (lhs, rhs, node) => {
 const collectPatternNames = (pattern, out = []) => {
     switch (pattern.type) {
         case "Identifier":
-            out.push(getString(pattern, "name"));
+            out.push(pattern.name);
             break;
         case "AssignmentPattern":
-            collectPatternNames(getNode(pattern, "left"), out);
+            collectPatternNames(pattern.left, out);
             break;
         case "RestElement":
-            collectPatternNames(getNode(pattern, "argument"), out);
+            collectPatternNames(pattern.argument, out);
             break;
         case "ArrayPattern":
-            for (const element of getArray(pattern, "elements")) {
+            for (const element of pattern.elements) {
                 if (element !== null)
-                    collectPatternNames(asNode(element, "elements"), out);
+                    collectPatternNames(element, out);
             }
             break;
         case "ObjectPattern":
-            for (const property of getArray(pattern, "properties")) {
-                const prop = asNode(property, "properties");
-                collectPatternNames(prop.type === "RestElement" ? getNode(prop, "argument") : getNode(prop, "value"), out);
+            for (const prop of pattern.properties) {
+                collectPatternNames(prop.type === "RestElement" ? prop.argument : prop.value, out);
             }
             break;
     }
@@ -116,13 +115,13 @@ const collectPatternNames = (pattern, out = []) => {
 const loopDeclaration = (left, statement) => {
     if (left.type !== "VariableDeclaration")
         return undefined;
-    const declarations = getArray(left, "declarations");
-    if (declarations.length !== 1) {
+    const declaration = left.declarations.length === 1 ? left.declarations[0] : undefined;
+    if (declaration === undefined) {
         throw new InterpreterRuntimeError(`${statement} supports one declared binding.`, left);
     }
-    const kind = getString(left, "kind");
+    const kind = left.kind;
     return {
-        pattern: getNode(asNode(declarations[0], "declarations[0]"), "id"),
+        pattern: declaration.id,
         mutable: kind !== "const",
         lexical: kind !== "var",
     };
@@ -140,7 +139,7 @@ const copyIteratorSymbols = (source, target, consumed) => {
             Reflect.set(target, symbol, Reflect.get(source, symbol));
     }
 };
-const promiseResolutionNode = { type: "PromiseResolution" };
+const promiseResolutionNode = { type: "PromiseResolution", start: 0, end: 0 };
 export class Interpreter {
     scopes;
     executeTool;
@@ -207,7 +206,7 @@ export class Interpreter {
             let value = undefined;
             for (const [index, statement] of program.body.entries()) {
                 if (index === program.body.length - 1 && statement.type === "ExpressionStatement") {
-                    value = yield* self.evaluateExpression(getNode(statement, "expression"));
+                    value = yield* self.evaluateExpression(statement.expression);
                     break;
                 }
                 const result = yield* self.evaluateStatement(statement);
@@ -242,11 +241,11 @@ export class Interpreter {
     evaluateStatement(node) {
         switch (node.type) {
             case "ExpressionStatement":
-                return Effect.as(this.evaluateExpression(getNode(node, "expression")), { kind: "none" });
+                return Effect.as(this.evaluateExpression(node.expression), { kind: "none" });
             case "VariableDeclaration":
                 return Effect.map(this.evaluateVariableDeclaration(node), () => ({ kind: "none" }));
             case "ReturnStatement": {
-                const argumentNode = getOptionalNode(node, "argument");
+                const argumentNode = node.argument;
                 return argumentNode
                     ? Effect.map(this.evaluateExpression(argumentNode), (value) => ({ kind: "return", value }))
                     : Effect.succeed({ kind: "return", value: undefined });
@@ -289,11 +288,10 @@ export class Interpreter {
         this.scopes.push();
         const self = this;
         return Effect.gen(function* () {
-            const body = getArray(node, "body");
+            const body = node.body;
             self.predeclareLexical(body);
             self.hoistFunctions(body);
-            for (const statementValue of body) {
-                const statement = asNode(statementValue, "body");
+            for (const statement of body) {
                 const result = yield* self.evaluateStatement(statement);
                 if (result.kind !== "none") {
                     return result;
@@ -303,27 +301,24 @@ export class Interpreter {
         }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
     }
     createFunction(node) {
-        return new CodeModeFunction(getArray(node, "params").map((parameter, index) => asNode(parameter, `params[${index}]`)), getNode(node, "body"), this.scopes.capture(), node.async === true, node.generator === true);
+        return new CodeModeFunction(node.params, node.body, this.scopes.capture(), node.async, node.generator);
     }
     hoistFunctions(statements) {
-        for (const statementValue of statements) {
-            if (!isRecord(statementValue) || statementValue.type !== "FunctionDeclaration")
+        for (const node of statements) {
+            if (node.type !== "FunctionDeclaration")
                 continue;
-            const node = statementValue;
-            this.scopes.declare(getString(getNode(node, "id"), "name"), this.createFunction(node), true, node);
+            this.scopes.declare(node.id.name, this.createFunction(node), true, node);
         }
     }
     predeclareLexical(statements) {
-        for (const statementValue of statements) {
-            if (!isRecord(statementValue) || statementValue.type !== "VariableDeclaration")
+        for (const statement of statements) {
+            if (statement.type !== "VariableDeclaration")
                 continue;
-            const statement = statementValue;
-            const kind = getString(statement, "kind");
+            const kind = statement.kind;
             if (kind === "var")
                 continue;
-            for (const declarationValue of getArray(statement, "declarations")) {
-                const declaration = asNode(declarationValue, "declarations");
-                for (const name of collectPatternNames(getNode(declaration, "id"))) {
+            for (const declaration of statement.declarations) {
+                for (const name of collectPatternNames(declaration.id)) {
                     this.scopes.reserve(name, kind !== "const", declaration);
                 }
             }
@@ -334,30 +329,27 @@ export class Interpreter {
             this.scopes.reserve(name, mutable, node);
     }
     evaluateIfStatement(node) {
-        const testNode = getNode(node, "test");
-        const consequentNode = getNode(node, "consequent");
-        const alternateNode = getOptionalNode(node, "alternate");
-        return Effect.flatMap(this.evaluateExpression(testNode), (test) => test
-            ? this.evaluateStatement(consequentNode)
-            : alternateNode
-                ? this.evaluateStatement(alternateNode)
+        return Effect.flatMap(this.evaluateExpression(node.test), (test) => test
+            ? this.evaluateStatement(node.consequent)
+            : node.alternate
+                ? this.evaluateStatement(node.alternate)
                 : Effect.succeed({ kind: "none" }));
     }
     evaluateSwitchStatement(node) {
         const self = this;
         return Effect.gen(function* () {
-            const discriminant = yield* self.evaluateExpression(getNode(node, "discriminant"));
+            const discriminant = yield* self.evaluateExpression(node.discriminant);
             if (containsOpaqueReference(discriminant)) {
                 throw new InterpreterRuntimeError("Switch discriminants must be data values.", node, "InvalidDataValue");
             }
             self.scopes.push();
             return yield* Effect.gen(function* () {
-                const cases = getArray(node, "cases").map((value, index) => asNode(value, `cases[${index}]`));
-                self.predeclareLexical(cases.flatMap((branch) => getArray(branch, "consequent")));
+                const cases = node.cases;
+                self.predeclareLexical(cases.flatMap((branch) => branch.consequent));
                 let defaultIndex;
                 let selected;
                 for (const [index, branch] of cases.entries()) {
-                    const test = getOptionalNode(branch, "test");
+                    const test = branch.test;
                     if (!test) {
                         defaultIndex = index;
                         continue;
@@ -375,8 +367,8 @@ export class Interpreter {
                 if (start === undefined)
                     return { kind: "none" };
                 for (let index = start; index < cases.length; index += 1) {
-                    for (const statementValue of getArray(cases[index], "consequent")) {
-                        const result = yield* self.evaluateStatement(asNode(statementValue, "consequent"));
+                    for (const statement of cases[index].consequent) {
+                        const result = yield* self.evaluateStatement(statement);
                         if (result.kind === "break") {
                             if (result.label === undefined)
                                 return { kind: "none" };
@@ -391,12 +383,10 @@ export class Interpreter {
         });
     }
     evaluateWhileStatement(node, labels) {
-        const testNode = getNode(node, "test");
-        const bodyNode = getNode(node, "body");
         const self = this;
         return Effect.gen(function* () {
-            while (yield* self.evaluateExpression(testNode)) {
-                const result = yield* self.evaluateStatement(bodyNode);
+            while (yield* self.evaluateExpression(node.test)) {
+                const result = yield* self.evaluateStatement(node.body);
                 if (result.kind === "continue") {
                     if (result.label !== undefined && !labels?.has(result.label))
                         return result;
@@ -415,12 +405,10 @@ export class Interpreter {
         });
     }
     evaluateDoWhileStatement(node, labels) {
-        const bodyNode = getNode(node, "body");
-        const testNode = getNode(node, "test");
         const self = this;
         return Effect.gen(function* () {
             do {
-                const result = yield* self.evaluateStatement(bodyNode);
+                const result = yield* self.evaluateStatement(node.body);
                 if (result.kind === "continue") {
                     if (result.label !== undefined && !labels?.has(result.label))
                         return result;
@@ -434,7 +422,7 @@ export class Interpreter {
                 if (result.kind === "return") {
                     return result;
                 }
-            } while (yield* self.evaluateExpression(testNode));
+            } while (yield* self.evaluateExpression(node.test));
             return { kind: "none" };
         });
     }
@@ -442,11 +430,10 @@ export class Interpreter {
         this.scopes.push();
         const self = this;
         return Effect.gen(function* () {
-            const initNode = getOptionalNode(node, "init");
-            const testNode = getOptionalNode(node, "test");
-            const updateNode = getOptionalNode(node, "update");
-            const bodyNode = getNode(node, "body");
-            if (initNode?.type === "VariableDeclaration" && getString(initNode, "kind") !== "var") {
+            const initNode = node.init;
+            const testNode = node.test;
+            const updateNode = node.update;
+            if (initNode?.type === "VariableDeclaration" && initNode.kind !== "var") {
                 self.predeclareLexical([initNode]);
             }
             if (initNode) {
@@ -457,7 +444,7 @@ export class Interpreter {
                     yield* self.evaluateExpression(initNode);
                 }
             }
-            const perIterationBindings = initNode?.type === "VariableDeclaration" && getString(initNode, "kind") !== "var"
+            const perIterationBindings = initNode?.type === "VariableDeclaration" && initNode.kind !== "var"
                 ? Array.from(self.scopes.current().keys())
                 : [];
             const nextIteration = () => {
@@ -469,7 +456,7 @@ export class Interpreter {
             };
             nextIteration();
             while (testNode ? yield* self.evaluateExpression(testNode) : true) {
-                const result = yield* self.evaluateStatement(bodyNode);
+                const result = yield* self.evaluateStatement(node.body);
                 if (result.kind === "return") {
                     return result;
                 }
@@ -492,8 +479,8 @@ export class Interpreter {
         }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
     }
     evaluateForOfStatement(node, labels) {
-        const awaiting = getBoolean(node, "await");
-        const left = getNode(node, "left");
+        const awaiting = node.await;
+        const left = node.left;
         const declared = loopDeclaration(left, "for...of");
         if (declared?.lexical)
             this.scopes.push();
@@ -501,8 +488,7 @@ export class Interpreter {
         return Effect.gen(function* () {
             if (declared?.lexical)
                 self.predeclarePattern(declared.pattern, declared.mutable, left);
-            const right = yield* self.evaluateExpression(getNode(node, "right"));
-            const body = getNode(node, "body");
+            const right = yield* self.evaluateExpression(node.right);
             const iterator = yield* self.customIterator(right, node, awaiting);
             const cursor = iterator === undefined ? yield* self.syncIterator(right, node) : undefined;
             if (iterator === undefined && cursor === undefined) {
@@ -513,17 +499,10 @@ export class Interpreter {
                 : awaiting
                     ? Effect.andThen(cursor?.close ?? Effect.void, Effect.yieldNow)
                     : (cursor?.close ?? Effect.void);
-            let assignment;
-            if (left.type !== "VariableDeclaration" &&
-                (left.type === "Identifier" ||
-                    left.type === "MemberExpression" ||
-                    left.type === "ArrayPattern" ||
-                    left.type === "ObjectPattern")) {
-                assignment = left;
-            }
-            else if (left.type !== "VariableDeclaration") {
+            if (left.type === "RestElement" || left.type === "AssignmentPattern") {
                 throw new InterpreterRuntimeError("Unsupported for...of binding.", left);
             }
+            const assignment = left.type === "VariableDeclaration" ? undefined : left;
             const evaluateBody = (value) => Effect.gen(function* () {
                 if (declared) {
                     self.scopes.push();
@@ -534,7 +513,7 @@ export class Interpreter {
                 else if (assignment) {
                     yield* self.assignPattern(assignment, value, left);
                 }
-                return yield* self.evaluateStatement(body);
+                return yield* self.evaluateStatement(node.body);
             }).pipe(Effect.ensuring(Effect.sync(() => {
                 if (declared)
                     self.scopes.pop();
@@ -734,7 +713,7 @@ export class Interpreter {
         return undefined;
     }
     evaluateForInStatement(node, labels) {
-        const left = getNode(node, "left");
+        const left = node.left;
         const declared = loopDeclaration(left, "for...in");
         if (declared?.lexical)
             this.scopes.push();
@@ -742,19 +721,15 @@ export class Interpreter {
         return Effect.gen(function* () {
             if (declared?.lexical)
                 self.predeclarePattern(declared.pattern, declared.mutable, left);
-            const right = yield* self.evaluateExpression(getNode(node, "right"));
-            const body = getNode(node, "body");
+            const right = yield* self.evaluateExpression(node.right);
             const keys = self.enumerableKeys(right);
             if (keys === undefined) {
                 throw new InterpreterRuntimeError("for...in requires a plain object, array, or tools reference. Use for...of for arrays/strings/Maps/Sets, or Object.keys(value) for a key list.", node);
             }
-            let assignmentName;
-            if (left.type === "Identifier") {
-                assignmentName = getString(left, "name");
-            }
-            else if (left.type !== "VariableDeclaration") {
+            if (left.type !== "Identifier" && left.type !== "VariableDeclaration") {
                 throw new InterpreterRuntimeError("Unsupported for...in binding.", left);
             }
+            const assignmentName = left.type === "Identifier" ? left.name : undefined;
             for (const key of keys) {
                 const result = yield* Effect.gen(function* () {
                     if (declared) {
@@ -766,7 +741,7 @@ export class Interpreter {
                     else if (assignmentName) {
                         self.scopes.set(assignmentName, key, left);
                     }
-                    return yield* self.evaluateStatement(body);
+                    return yield* self.evaluateStatement(node.body);
                 }).pipe(Effect.ensuring(Effect.sync(() => {
                     if (declared)
                         self.scopes.pop();
@@ -792,19 +767,17 @@ export class Interpreter {
         })));
     }
     evaluateBreakStatement(node) {
-        const labelNode = getOptionalNode(node, "label");
-        return labelNode ? { kind: "break", label: getString(labelNode, "name") } : { kind: "break" };
+        return node.label ? { kind: "break", label: node.label.name } : { kind: "break" };
     }
     evaluateContinueStatement(node) {
-        const labelNode = getOptionalNode(node, "label");
-        return labelNode ? { kind: "continue", label: getString(labelNode, "name") } : { kind: "continue" };
+        return node.label ? { kind: "continue", label: node.label.name } : { kind: "continue" };
     }
     evaluateLabeledStatement(node) {
         const labels = new Set();
         let body = node;
         while (body.type === "LabeledStatement") {
-            labels.add(getString(getNode(body, "label"), "name"));
-            body = getNode(body, "body");
+            labels.add(body.label.name);
+            body = body.body;
         }
         const evaluated = (() => {
             if (body.type === "WhileStatement")
@@ -824,13 +797,12 @@ export class Interpreter {
             : result);
     }
     evaluateThrowStatement(node) {
-        const argument = getNode(node, "argument");
-        return Effect.flatMap(this.evaluateExpression(argument), (value) => Effect.fail(new ProgramThrow(value)));
+        return Effect.flatMap(this.evaluateExpression(node.argument), (value) => Effect.fail(new ProgramThrow(value)));
     }
     evaluateTryStatement(node) {
-        const body = getNode(node, "block");
-        const handler = getOptionalNode(node, "handler");
-        const finalizer = getOptionalNode(node, "finalizer");
+        const body = node.block;
+        const handler = node.handler;
+        const finalizer = node.finalizer;
         const self = this;
         const attempted = Effect.matchCauseEffect(this.evaluateStatement(body), {
             onFailure: (cause) => {
@@ -838,12 +810,12 @@ export class Interpreter {
                     return Effect.failCause(cause);
                 }
                 const caught = caughtErrorValue(Cause.squash(cause));
-                const parameter = getOptionalNode(handler, "param");
+                const parameter = handler.param;
                 self.scopes.push();
                 return Effect.gen(function* () {
                     if (parameter)
                         yield* self.declarePattern(parameter, caught, true, handler);
-                    return yield* self.evaluateStatement(getNode(handler, "body"));
+                    return yield* self.evaluateStatement(handler.body);
                 }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
             },
             onSuccess: Effect.succeed,
@@ -859,18 +831,16 @@ export class Interpreter {
         });
     }
     evaluateVariableDeclaration(node) {
-        const kind = getString(node, "kind");
-        const declarations = getArray(node, "declarations");
+        const kind = node.kind;
         const self = this;
         return Effect.gen(function* () {
-            for (const declarationValue of declarations) {
-                const declaration = asNode(declarationValue, "declarations");
+            for (const declaration of node.declarations) {
                 if (declaration.type !== "VariableDeclarator") {
                     throw new InterpreterRuntimeError("Unsupported variable declaration shape.", declaration);
                 }
-                const init = getOptionalNode(declaration, "init");
+                const init = declaration.init;
                 const value = init ? yield* self.evaluateExpression(init) : undefined;
-                yield* self.declarePattern(getNode(declaration, "id"), value, kind !== "const", declaration, kind !== "var");
+                yield* self.declarePattern(declaration.id, value, kind !== "const", declaration, kind !== "var");
             }
         });
     }
@@ -878,7 +848,7 @@ export class Interpreter {
         const self = this;
         return Effect.gen(function* () {
             if (pattern.type === "Identifier") {
-                const name = getString(pattern, "name");
+                const name = pattern.name;
                 if (initialize)
                     self.scopes.initialize(name, value, node);
                 else
@@ -886,8 +856,8 @@ export class Interpreter {
                 return;
             }
             if (pattern.type === "AssignmentPattern") {
-                const resolved = value === undefined ? yield* self.evaluateExpression(getNode(pattern, "right")) : value;
-                yield* self.declarePattern(getNode(pattern, "left"), resolved, mutable, node, initialize);
+                const resolved = value === undefined ? yield* self.evaluateExpression(pattern.right) : value;
+                yield* self.declarePattern(pattern.left, resolved, mutable, node, initialize);
                 return;
             }
             if (pattern.type === "ObjectPattern") {
@@ -895,8 +865,7 @@ export class Interpreter {
                     throw new InterpreterRuntimeError("Object destructuring requires a data object or array value.", pattern, "InvalidDataValue");
                 }
                 const consumed = new Set();
-                for (const propertyValue of getArray(pattern, "properties")) {
-                    const property = asNode(propertyValue, "properties");
+                for (const property of pattern.properties) {
                     if (property.type === "RestElement") {
                         const rest = Object.create(null);
                         for (const [key, item] of Object.entries(value)) {
@@ -904,7 +873,7 @@ export class Interpreter {
                                 rest[key] = item;
                         }
                         copyIteratorSymbols(value, rest, consumed);
-                        yield* self.declarePattern(getNode(property, "argument"), rest, mutable, property, initialize);
+                        yield* self.declarePattern(property.argument, rest, mutable, property, initialize);
                         continue;
                     }
                     const key = yield* self.destructuringPropertyKey(property);
@@ -912,7 +881,7 @@ export class Interpreter {
                         throw new InterpreterRuntimeError(`Property '${String(key)}' is not available.`, property);
                     }
                     consumed.add(typeof key === "symbol" ? key : String(key));
-                    yield* self.declarePattern(getNode(property, "value"), self.destructuringPropertyValue(value, key), mutable, property, initialize);
+                    yield* self.declarePattern(property.value, self.destructuringPropertyValue(value, key), mutable, property, initialize);
                 }
                 return;
             }
@@ -926,7 +895,7 @@ export class Interpreter {
         const self = this;
         return Effect.gen(function* () {
             if (pattern.type === "Identifier") {
-                self.scopes.set(getString(pattern, "name"), value, pattern);
+                self.scopes.set(pattern.name, value, pattern);
                 return;
             }
             if (pattern.type === "MemberExpression") {
@@ -934,8 +903,8 @@ export class Interpreter {
                 return;
             }
             if (pattern.type === "AssignmentPattern") {
-                const resolved = value === undefined ? yield* self.evaluateExpression(getNode(pattern, "right")) : value;
-                yield* self.assignPattern(getNode(pattern, "left"), resolved, node);
+                const resolved = value === undefined ? yield* self.evaluateExpression(pattern.right) : value;
+                yield* self.assignPattern(pattern.left, resolved, node);
                 return;
             }
             if (pattern.type === "ObjectPattern") {
@@ -944,8 +913,7 @@ export class Interpreter {
                 }
                 const source = value;
                 const consumed = new Set();
-                for (const propertyValue of getArray(pattern, "properties")) {
-                    const property = asNode(propertyValue, "properties");
+                for (const property of pattern.properties) {
                     if (property.type === "RestElement") {
                         const rest = Object.create(null);
                         for (const [key, item] of Object.entries(source)) {
@@ -953,7 +921,7 @@ export class Interpreter {
                                 rest[key] = item;
                         }
                         copyIteratorSymbols(source, rest, consumed);
-                        yield* self.assignPattern(getNode(property, "argument"), rest, property);
+                        yield* self.assignPattern(property.argument, rest, property);
                         continue;
                     }
                     const key = yield* self.destructuringPropertyKey(property);
@@ -961,7 +929,7 @@ export class Interpreter {
                         throw new InterpreterRuntimeError(`Property '${String(key)}' is not available.`, property);
                     }
                     consumed.add(typeof key === "symbol" ? key : String(key));
-                    yield* self.assignPattern(getNode(property, "value"), self.destructuringPropertyValue(source, key), property);
+                    yield* self.assignPattern(property.value, self.destructuringPropertyValue(source, key), property);
                 }
                 return;
             }
@@ -979,21 +947,19 @@ export class Interpreter {
                 throw new InterpreterRuntimeError("Array destructuring requires a supported iterable value.", pattern).as("TypeError");
             }
             let done = false;
-            for (const [index, item] of getArray(pattern, "elements").entries()) {
+            for (const element of pattern.elements) {
                 if (done) {
-                    if (item === null)
+                    if (element === null)
                         continue;
-                    const element = asNode(item, `elements[${index}]`);
-                    yield* consume(element.type === "RestElement" ? getNode(element, "argument") : element, element.type === "RestElement" ? [] : undefined, element);
+                    yield* consume(element.type === "RestElement" ? element.argument : element, element.type === "RestElement" ? [] : undefined, element);
                     if (element.type === "RestElement")
                         return;
                     continue;
                 }
                 const step = yield* cursor.next;
                 done = step.done;
-                if (item === null)
+                if (element === null)
                     continue;
-                const element = asNode(item, `elements[${index}]`);
                 if (element.type === "RestElement") {
                     const rest = [];
                     if (!step.done)
@@ -1004,7 +970,7 @@ export class Interpreter {
                         if (!done)
                             rest.push(next.value);
                     }
-                    yield* consume(getNode(element, "argument"), rest, element);
+                    yield* consume(element.argument, rest, element);
                     return;
                 }
                 const consumed = consume(element, step.done ? undefined : step.value, pattern);
@@ -1015,14 +981,18 @@ export class Interpreter {
         });
     }
     destructuringPropertyKey(property) {
-        if (property.type !== "Property" || getString(property, "kind") !== "init") {
+        if (property.type !== "Property" || property.kind !== "init") {
             throw new InterpreterRuntimeError("Unsupported object destructuring property.", property);
         }
-        const keyNode = getNode(property, "key");
-        if (getBoolean(property, "computed")) {
+        const keyNode = property.key;
+        if (property.computed) {
             return Effect.map(this.evaluateExpression(keyNode), (value) => this.toPropertyKey(value, keyNode));
         }
-        return Effect.succeed(keyNode.type === "Identifier" ? getString(keyNode, "name") : String(keyNode.value));
+        if (keyNode.type === "Identifier")
+            return Effect.succeed(keyNode.name);
+        if (keyNode.type === "Literal")
+            return Effect.succeed(String(keyNode.value));
+        throw unsupportedSyntax(keyNode.type, keyNode);
     }
     destructuringPropertyValue(source, key) {
         if (!Array.isArray(source))
@@ -1041,13 +1011,12 @@ export class Interpreter {
         switch (node.type) {
             case "Literal": {
                 const regex = node.regex;
-                if (isRecord(regex) && typeof regex.pattern === "string") {
-                    return Effect.sync(() => this.constructRegExp([regex.pattern, typeof regex.flags === "string" ? regex.flags : ""], node));
-                }
+                if (regex)
+                    return Effect.sync(() => this.constructRegExp([regex.pattern, regex.flags], node));
                 return Effect.sync(() => toProgram(node.value, "Literal"));
             }
             case "Identifier":
-                return Effect.sync(() => this.scopes.get(getString(node, "name"), node));
+                return Effect.sync(() => this.scopes.get(node.name, node));
             case "BinaryExpression":
                 return this.evaluateBinaryExpression(node);
             case "LogicalExpression":
@@ -1060,8 +1029,8 @@ export class Interpreter {
                 const self = this;
                 return Effect.gen(function* () {
                     let result;
-                    for (const expression of getArray(node, "expressions")) {
-                        result = yield* self.evaluateExpression(asNode(expression, "expressions"));
+                    for (const expression of node.expressions) {
+                        result = yield* self.evaluateExpression(expression);
                     }
                     return result;
                 });
@@ -1074,7 +1043,7 @@ export class Interpreter {
             case "MemberExpression":
                 return this.readMember(node);
             case "ChainExpression":
-                return Effect.map(this.evaluateExpression(getNode(node, "expression")), (value) => value === OptionalShortCircuit ? undefined : value);
+                return Effect.map(this.evaluateExpression(node.expression), (value) => value === OptionalShortCircuit ? undefined : value);
             case "ObjectExpression":
                 return this.evaluateObjectExpression(node);
             case "ArrayExpression":
@@ -1087,7 +1056,7 @@ export class Interpreter {
                 return this.evaluateUpdateExpression(node);
             case "AwaitExpression": {
                 // Await always suspends, including for plain values.
-                return Effect.flatMap(this.evaluateExpression(getNode(node, "argument")), (value) => this.awaitValue(value, node));
+                return Effect.flatMap(this.evaluateExpression(node.argument), (value) => this.awaitValue(value, node));
             }
             case "YieldExpression":
                 return this.evaluateYieldExpression(node);
@@ -1098,12 +1067,12 @@ export class Interpreter {
         }
     }
     evaluateNewExpression(node) {
-        const callee = getNode(node, "callee");
+        const callee = node.callee;
         if (callee.type !== "Identifier") {
             throw unsupportedSyntax("NewExpression", node);
         }
-        const name = getString(callee, "name");
-        const argNodes = getArray(node, "arguments");
+        const name = callee.name;
+        const argNodes = node.arguments;
         const self = this;
         if (name === "Promise") {
             return Effect.flatMap(this.evaluateCallArguments(argNodes), (args) => constructPromise(self.runner, self.promises, args[0], node));
@@ -1303,11 +1272,14 @@ export class Interpreter {
         });
     }
     evaluateBinaryExpression(node) {
-        const operator = getString(node, "operator");
+        const operator = node.operator;
+        const left = node.left;
+        if (left.type === "PrivateIdentifier")
+            throw unsupportedSyntax(left.type, left);
         const self = this;
         return Effect.gen(function* () {
-            const lhs = yield* self.evaluateExpression(getNode(node, "left"));
-            const rhs = yield* self.evaluateExpression(getNode(node, "right"));
+            const lhs = yield* self.evaluateExpression(left);
+            const rhs = yield* self.evaluateExpression(node.right);
             if (operator === "instanceof")
                 return instanceofValue(lhs, rhs, node);
             return toProgram(self.applyBinaryOperator(operator, lhs, rhs, node), "Binary expression result");
@@ -1380,26 +1352,24 @@ export class Interpreter {
         }
     }
     evaluateLogicalExpression(node) {
-        const operator = getString(node, "operator");
-        return Effect.flatMap(this.evaluateExpression(getNode(node, "left")), (left) => {
+        const operator = node.operator;
+        return Effect.flatMap(this.evaluateExpression(node.left), (left) => {
             if (operator === "&&")
-                return left ? this.evaluateExpression(getNode(node, "right")) : Effect.succeed(left);
+                return left ? this.evaluateExpression(node.right) : Effect.succeed(left);
             if (operator === "||")
-                return left ? Effect.succeed(left) : this.evaluateExpression(getNode(node, "right"));
+                return left ? Effect.succeed(left) : this.evaluateExpression(node.right);
             if (operator === "??")
-                return left !== null && left !== undefined
-                    ? Effect.succeed(left)
-                    : this.evaluateExpression(getNode(node, "right"));
+                return left !== null && left !== undefined ? Effect.succeed(left) : this.evaluateExpression(node.right);
             throw new InterpreterRuntimeError(`Unsupported logical operator '${operator}'.`, node);
         });
     }
     evaluateUnaryExpression(node) {
-        const operator = getString(node, "operator");
-        const argument = getNode(node, "argument");
+        const operator = node.operator;
+        const argument = node.argument;
         if (operator === "delete")
             return this.evaluateDeleteExpression(argument);
         // Undeclared names short-circuit, but declared TDZ bindings must still throw.
-        if (operator === "typeof" && argument.type === "Identifier" && !this.scopes.resolve(getString(argument, "name"))) {
+        if (operator === "typeof" && argument.type === "Identifier" && !this.scopes.resolve(argument.name)) {
             return Effect.succeed("undefined");
         }
         return Effect.map(this.evaluateExpression(argument), (value) => {
@@ -1435,31 +1405,31 @@ export class Interpreter {
         });
     }
     evaluateAssignmentExpression(node) {
-        const left = getNode(node, "left");
-        const operator = getString(node, "operator");
+        const left = node.left;
+        const operator = node.operator;
         const self = this;
         return Effect.gen(function* () {
             if (operator === "??=" || operator === "||=" || operator === "&&=") {
                 return yield* self.evaluateLogicalAssignment(node, left, operator);
             }
             if (operator === "=" && (left.type === "ObjectPattern" || left.type === "ArrayPattern")) {
-                const rightValue = yield* self.evaluateExpression(getNode(node, "right"));
+                const rightValue = yield* self.evaluateExpression(node.right);
                 yield* self.assignPattern(left, rightValue, node);
                 return rightValue;
             }
             if (left.type === "Identifier") {
-                const name = getString(left, "name");
+                const name = left.name;
                 if (operator !== "=") {
                     const current = self.scopes.get(name, left);
-                    const rightValue = yield* self.evaluateExpression(getNode(node, "right"));
+                    const rightValue = yield* self.evaluateExpression(node.right);
                     const next = toProgram(self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
                     return self.scopes.set(name, next, left);
                 }
-                const rightValue = yield* self.evaluateExpression(getNode(node, "right"));
+                const rightValue = yield* self.evaluateExpression(node.right);
                 return self.scopes.set(name, rightValue, left);
             }
             if (left.type === "MemberExpression") {
-                return yield* self.modifyMember(left, (current) => Effect.map(self.evaluateExpression(getNode(node, "right")), (rightValue) => {
+                return yield* self.modifyMember(left, (current) => Effect.map(self.evaluateExpression(node.right), (rightValue) => {
                     if (operator === "=")
                         return { write: true, next: rightValue, result: rightValue };
                     const next = toProgram(self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
@@ -1473,18 +1443,18 @@ export class Interpreter {
         const self = this;
         const shouldAssign = (current) => operator === "??=" ? current === null || current === undefined : operator === "||=" ? !current : Boolean(current);
         if (left.type === "Identifier") {
-            const name = getString(left, "name");
+            const name = left.name;
             return Effect.gen(function* () {
                 const current = self.scopes.get(name, left);
                 if (!shouldAssign(current))
                     return current;
-                const rightValue = yield* self.evaluateExpression(getNode(node, "right"));
+                const rightValue = yield* self.evaluateExpression(node.right);
                 return self.scopes.set(name, rightValue, left);
             });
         }
         if (left.type === "MemberExpression") {
             return self.modifyMember(left, (current) => shouldAssign(current)
-                ? Effect.map(self.evaluateExpression(getNode(node, "right")), (rightValue) => ({
+                ? Effect.map(self.evaluateExpression(node.right), (rightValue) => ({
                     write: true,
                     next: rightValue,
                     result: rightValue,
@@ -1494,9 +1464,9 @@ export class Interpreter {
         throw new InterpreterRuntimeError("Assignment target must be an Identifier or MemberExpression.", left);
     }
     evaluateUpdateExpression(node) {
-        const operator = getString(node, "operator");
-        const argument = getNode(node, "argument");
-        const prefix = getBoolean(node, "prefix");
+        const operator = node.operator;
+        const argument = node.argument;
+        const prefix = node.prefix;
         const increment = operator === "++" ? 1 : operator === "--" ? -1 : undefined;
         if (increment === undefined) {
             throw new InterpreterRuntimeError(`Unsupported update operator '${operator}'.`, node);
@@ -1511,7 +1481,7 @@ export class Interpreter {
         };
         if (argument.type === "Identifier") {
             return Effect.sync(() => {
-                const name = getString(argument, "name");
+                const name = argument.name;
                 const current = operand(this.scopes.get(name, argument));
                 const next = current + increment;
                 this.scopes.set(name, next, argument);
@@ -1528,26 +1498,28 @@ export class Interpreter {
         throw new InterpreterRuntimeError("Update target must be an Identifier or MemberExpression.", argument);
     }
     evaluateCallExpression(node) {
-        const callee = getNode(node, "callee");
-        const argNodes = getArray(node, "arguments");
+        const callee = node.callee;
         const self = this;
         return Effect.gen(function* () {
+            if (callee.type === "Super")
+                throw unsupportedSyntax(callee.type, callee);
             const callable = yield* self.evaluateExpression(callee);
             if (callable === OptionalShortCircuit)
                 return OptionalShortCircuit;
-            if ((callable === null || callable === undefined) && node.optional === true)
+            if ((callable === null || callable === undefined) && node.optional)
                 return OptionalShortCircuit;
-            const args = yield* self.evaluateCallArguments(argNodes);
+            const args = yield* self.evaluateCallArguments(node.arguments);
             return yield* self.invokeCallable(callable, args, node, callee);
         });
     }
     // The single dispatch for every invocation: call expressions and callbacks share it.
-    invokeCallable(callable, args, node, callee = node) {
+    invokeCallable(callable, args, node, callee) {
         const self = this;
         return Effect.gen(function* () {
             if (callable instanceof ToolReference) {
-                if (callable.path.length === 0)
-                    throw new InterpreterRuntimeError("The tools root is not callable.", callee);
+                if (callable.path.length === 0) {
+                    throw new InterpreterRuntimeError("The tools root is not callable.", callee ?? node);
+                }
                 return yield* self.createToolCallPromise(callable.path, args);
             }
             if (callable instanceof PromiseMethodReference) {
@@ -1638,9 +1610,9 @@ export class Interpreter {
                 return undefined;
             }
             if (callable === undefined || callable === null) {
-                throw new InterpreterRuntimeError(`${calleeDescription(callee)} is not a function.`, callee).as("TypeError");
+                throw new InterpreterRuntimeError(`${calleeDescription(callee)} is not a function.`, callee ?? node).as("TypeError");
             }
-            throw new InterpreterRuntimeError("Only tools are callable here.", callee);
+            throw new InterpreterRuntimeError("Only tools are callable here.", callee ?? node);
         });
     }
     invokeObjectMethodOnTools(name, ref, node) {
@@ -1659,10 +1631,9 @@ export class Interpreter {
         const self = this;
         return Effect.gen(function* () {
             const args = [];
-            for (const [index, arg] of argNodes.entries()) {
-                const argNode = asNode(arg, `arguments[${index}]`);
+            for (const argNode of argNodes) {
                 if (argNode.type === "SpreadElement") {
-                    const spread = yield* self.evaluateExpression(getNode(argNode, "argument"));
+                    const spread = yield* self.evaluateExpression(argNode.argument);
                     const cursor = yield* self.syncIterator(spread, argNode);
                     if (cursor === undefined)
                         throw new InterpreterRuntimeError("Spread arguments require a synchronous iterable.", argNode).as("TypeError");
@@ -1693,7 +1664,7 @@ export class Interpreter {
             }
             for (const [index, parameter] of fn.parameters.entries()) {
                 if (parameter.type === "RestElement") {
-                    yield* invocation.declarePattern(getNode(parameter, "argument"), args.slice(index), true, parameter, true);
+                    yield* invocation.declarePattern(parameter.argument, args.slice(index), true, parameter, true);
                     break;
                 }
                 yield* invocation.declarePattern(parameter, args[index], true, parameter, true);
@@ -1814,12 +1785,12 @@ export class Interpreter {
         return request;
     }
     evaluateYieldExpression(node) {
-        const argument = getOptionalNode(node, "argument");
+        const argument = node.argument;
         const self = this;
         return Effect.gen(function* () {
             if (!self.generatorState)
                 throw new InterpreterRuntimeError("yield is only valid inside a generator.", node);
-            if (node.delegate === true) {
+            if (node.delegate) {
                 const value = argument ? yield* self.evaluateExpression(argument) : undefined;
                 return yield* self.delegateYield(value, node);
             }
@@ -1920,13 +1891,11 @@ export class Interpreter {
     }
     evaluateObjectExpression(node) {
         const objectValue = Object.create(null);
-        const properties = getArray(node, "properties");
         const self = this;
         return Effect.gen(function* () {
-            for (const propertyValue of properties) {
-                const property = asNode(propertyValue, "properties");
+            for (const property of node.properties) {
                 if (property.type === "SpreadElement") {
-                    const spread = yield* self.evaluateExpression(getNode(property, "argument"));
+                    const spread = yield* self.evaluateExpression(property.argument);
                     if (spread === null || spread === undefined || Values.isValue(spread))
                         continue;
                     if (typeof spread !== "object" || Array.isArray(spread) || isRuntimeReference(spread)) {
@@ -1940,21 +1909,16 @@ export class Interpreter {
                     copyIteratorSymbols(spread, objectValue);
                     continue;
                 }
-                if (property.type !== "Property") {
-                    throw new InterpreterRuntimeError("Only standard object properties are supported.", property);
-                }
-                if (getString(property, "kind") !== "init") {
+                if (property.kind !== "init") {
                     throw new InterpreterRuntimeError("Only init object properties are supported.", property);
                 }
-                const keyNode = getNode(property, "key");
-                const valueNode = getNode(property, "value");
-                const computed = getBoolean(property, "computed");
+                const keyNode = property.key;
                 let key;
-                if (computed) {
+                if (property.computed) {
                     key = self.toPropertyKey(yield* self.evaluateExpression(keyNode), keyNode);
                 }
                 else if (keyNode.type === "Identifier") {
-                    key = getString(keyNode, "name");
+                    key = keyNode.name;
                 }
                 else if (keyNode.type === "Literal") {
                     key = self.toPropertyKey(keyNode.value, keyNode);
@@ -1965,25 +1929,23 @@ export class Interpreter {
                 if (isBlockedMember(String(key))) {
                     throw new InterpreterRuntimeError(`Property '${String(key)}' is not available.`, keyNode);
                 }
-                Reflect.set(objectValue, key, yield* self.evaluateExpression(valueNode));
+                Reflect.set(objectValue, key, yield* self.evaluateExpression(property.value));
             }
             return objectValue;
         });
     }
     evaluateArrayExpression(node) {
-        const elements = getArray(node, "elements");
         const values = [];
         const self = this;
         return Effect.gen(function* () {
-            for (const elementValue of elements) {
-                if (elementValue === null) {
+            for (const element of node.elements) {
+                if (element === null) {
                     // A literal elision is a real hole, like JS: extend length without an own index.
                     values.length += 1;
                     continue;
                 }
-                const element = asNode(elementValue, "elements");
                 if (element.type === "SpreadElement") {
-                    const spread = yield* self.evaluateExpression(getNode(element, "argument"));
+                    const spread = yield* self.evaluateExpression(element.argument);
                     const cursor = yield* self.syncIterator(spread, element);
                     if (cursor === undefined)
                         throw new InterpreterRuntimeError("Array spread requires a synchronous iterable.", element).as("TypeError");
@@ -2002,20 +1964,20 @@ export class Interpreter {
         });
     }
     evaluateTemplateLiteral(node) {
-        const quasis = getArray(node, "quasis");
-        const expressions = getArray(node, "expressions");
+        const quasis = node.quasis;
+        const expressions = node.expressions;
         let output = "";
         const self = this;
         return Effect.gen(function* () {
             for (let index = 0; index < quasis.length; index += 1) {
-                const quasi = asNode(quasis[index], "quasis");
-                const rawValue = quasi.value;
-                if (!isRecord(rawValue) || typeof rawValue.cooked !== "string") {
+                const quasi = quasis[index];
+                // acorn only omits `cooked` for invalid escapes in tagged templates, which are unsupported.
+                if (typeof quasi.value.cooked !== "string") {
                     throw new InterpreterRuntimeError("Invalid template literal quasi.", quasi);
                 }
-                output += rawValue.cooked;
+                output += quasi.value.cooked;
                 if (index < expressions.length) {
-                    const raw = yield* self.evaluateExpression(asNode(expressions[index], "expressions"));
+                    const raw = yield* self.evaluateExpression(expressions[index]);
                     output += coerceToString(toProgram(raw, "Template interpolation"));
                 }
             }
@@ -2023,7 +1985,7 @@ export class Interpreter {
         });
     }
     evaluateConditionalExpression(node) {
-        return Effect.flatMap(this.evaluateExpression(getNode(node, "test")), (test) => this.evaluateExpression(getNode(node, test ? "consequent" : "alternate")));
+        return Effect.flatMap(this.evaluateExpression(node.test), (test) => this.evaluateExpression(test ? node.consequent : node.alternate));
     }
     applyCompoundAssignment(operator, current, incoming, node) {
         if (!compoundOperators.has(operator)) {
@@ -2032,21 +1994,23 @@ export class Interpreter {
         return this.applyBinaryOperator(operator.slice(0, -1), current, incoming, node);
     }
     getMemberReference(node, operation = "read") {
-        const objectNode = getNode(node, "object");
-        const propertyNode = getNode(node, "property");
-        const computed = getBoolean(node, "computed");
-        const optional = node.optional === true;
+        const objectNode = node.object;
+        const propertyNode = node.property;
+        if (objectNode.type === "Super")
+            throw unsupportedSyntax(objectNode.type, objectNode);
+        if (propertyNode.type === "PrivateIdentifier")
+            throw unsupportedSyntax(propertyNode.type, propertyNode);
         const self = this;
         return Effect.gen(function* () {
             const objectValue = yield* self.evaluateExpression(objectNode);
             if (objectValue === OptionalShortCircuit)
                 return OptionalShortCircuit;
-            if ((objectValue === null || objectValue === undefined) && optional)
+            if ((objectValue === null || objectValue === undefined) && node.optional)
                 return OptionalShortCircuit;
-            const key = computed
+            const key = node.computed
                 ? self.toPropertyKey(yield* self.evaluateExpression(propertyNode), propertyNode)
                 : propertyNode.type === "Identifier"
-                    ? getString(propertyNode, "name")
+                    ? propertyNode.name
                     : self.toPropertyKey(yield* self.evaluateExpression(propertyNode), propertyNode);
             if (objectValue instanceof ToolReference) {
                 if (typeof key !== "string") {
@@ -2234,7 +2198,7 @@ export class Interpreter {
         return this.modifyMember(node, () => Effect.succeed({ write: true, next: value, result: value }));
     }
     evaluateDeleteExpression(argument) {
-        const target = argument.type === "ChainExpression" ? getNode(argument, "expression") : argument;
+        const target = argument.type === "ChainExpression" ? argument.expression : argument;
         if (target.type !== "MemberExpression") {
             throw new InterpreterRuntimeError("Only data fields may be deleted.", argument);
         }

package/package.json

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