poe-code 6.0.0 → 7.0.1

package/dist/index.js

@@ -118875,6 +118875,97 @@ var init_error_codes21 = __esm({
   }
 });
 
+// packages/safejs/src/parse/bindings.ts
+function* boundIdentifiers(pattern) {
+  switch (pattern.type) {
+    case "Identifier":
+      yield pattern;
+      return;
+    case "AssignmentPattern":
+      yield* boundIdentifiers(pattern.left);
+      return;
+    case "RestElement":
+      yield* boundIdentifiers(pattern.argument);
+      return;
+    case "ArrayPattern":
+      for (const element of pattern.elements) {
+        if (element !== null) yield* boundIdentifiers(element);
+      }
+      return;
+    case "ObjectPattern":
+      for (const property of pattern.properties) {
+        yield* boundIdentifiers(property.type === "RestElement" ? property : property.value);
+      }
+      return;
+    case "MemberExpression":
+      return;
+  }
+}
+function containsParameterExpression(pattern) {
+  switch (pattern.type) {
+    case "AssignmentPattern":
+    case "MemberExpression":
+      return true;
+    case "RestElement":
+      return containsParameterExpression(pattern.argument);
+    case "ArrayPattern":
+      return pattern.elements.some(
+        (element) => element !== null && containsParameterExpression(element)
+      );
+    case "ObjectPattern":
+      return pattern.properties.some(
+        (property) => property.type === "RestElement" ? containsParameterExpression(property.argument) : property.computed || containsParameterExpression(property.value)
+      );
+    case "Identifier":
+      return false;
+  }
+}
+function* hoistedVarDeclarations(nodes) {
+  for (const node of nodes) {
+    switch (node.type) {
+      case "VariableDeclaration":
+        if (node.kind === "var") yield node;
+        break;
+      case "BlockStatement":
+        yield* hoistedVarDeclarations(node.body);
+        break;
+      case "IfStatement":
+        yield* hoistedVarDeclarations([node.consequent]);
+        if (node.alternate !== void 0) yield* hoistedVarDeclarations([node.alternate]);
+        break;
+      case "ForStatement":
+        if (node.init?.type === "VariableDeclaration") yield* hoistedVarDeclarations([node.init]);
+        yield* hoistedVarDeclarations([node.body]);
+        break;
+      case "ForInStatement":
+      case "ForOfStatement":
+        if (node.left.type === "VariableDeclaration") yield* hoistedVarDeclarations([node.left]);
+        yield* hoistedVarDeclarations([node.body]);
+        break;
+      case "WhileStatement":
+      case "DoWhileStatement":
+        yield* hoistedVarDeclarations([node.body]);
+        break;
+      case "TryStatement":
+        yield* hoistedVarDeclarations([node.block]);
+        if (node.handler !== void 0) yield* hoistedVarDeclarations([node.handler.body]);
+        if (node.finalizer !== void 0) yield* hoistedVarDeclarations([node.finalizer]);
+        break;
+      case "SwitchStatement":
+        for (const switchCase of node.cases) yield* hoistedVarDeclarations(switchCase.consequent);
+        break;
+      case "ExportNamedDeclaration":
+        yield* hoistedVarDeclarations([node.declaration]);
+        break;
+    }
+  }
+}
+var init_bindings = __esm({
+  "packages/safejs/src/parse/bindings.ts"() {
+    "use strict";
+  }
+});
+
 // packages/safejs/src/parse/tokenizer.ts
 function tokenize3(source, options = {}) {
   const lexer = new Lexer(source, options);
@@ -120692,26 +120783,6 @@ function createIdentifierName(token) {
     span: createTokenSpan(token)
   };
 }
-function collectBindingIdentifiers(pattern) {
-  switch (pattern.type) {
-    case "Identifier":
-      return [pattern];
-    case "MemberExpression":
-      return [];
-    case "AssignmentPattern":
-      return collectBindingIdentifiers(pattern.left);
-    case "RestElement":
-      return collectBindingIdentifiers(pattern.argument);
-    case "ArrayPattern":
-      return pattern.elements.flatMap(
-        (element) => element === null ? [] : collectBindingIdentifiers(element)
-      );
-    case "ObjectPattern":
-      return pattern.properties.flatMap(
-        (property) => property.type === "RestElement" ? collectBindingIdentifiers(property) : collectBindingIdentifiers(property.value)
-      );
-  }
-}
 function createLoopLabelFields(labels) {
   if (labels === void 0 || labels.length === 0) {
     return {};
@@ -121509,6 +121580,7 @@ var MAX_CONDITIONAL_EXPRESSION_DEPTH, MAX_IF_STATEMENT_DEPTH, DisallowedSyntaxEr
 var init_parser3 = __esm({
   "packages/safejs/src/parse/parser.ts"() {
     "use strict";
+    init_bindings();
     init_tokenizer2();
     init_assign_ids();
     init_format_error();
@@ -121550,6 +121622,7 @@ var init_parser3 = __esm({
     Parser = class {
       constructor(tokens) {
         this.tokens = tokens;
+        this.functionScopes.add(this.scopes[0]);
       }
       tokens;
       index = 0;
@@ -121559,6 +121632,8 @@ var init_parser3 = __esm({
       loopDepth = 0;
       generatorBody = false;
       scopes = [/* @__PURE__ */ new Map()];
+      functionScopes = /* @__PURE__ */ new WeakSet();
+      varNames = /* @__PURE__ */ new WeakMap();
       parseTopLevel() {
         if (this.isExportToken(this.currentToken())) {
           throw new DisallowedSyntaxError("export", this.currentToken().start);
@@ -121693,8 +121768,13 @@ var init_parser3 = __esm({
         return void 0;
       }
       finishArrowFunctionExpression(start, isAsync, params) {
+        this.withScope(() => {
+          for (const param of params) {
+            for (const identifier of boundIdentifiers(param)) this.declareBinding(identifier);
+          }
+        });
         this.expectPunctuator("=>");
-        const body = this.parseArrowFunctionBody();
+        const body = this.parseArrowFunctionBody(params);
         return {
           type: "ArrowFunctionExpression",
           async: isAsync,
@@ -121734,15 +121814,27 @@ var init_parser3 = __esm({
           this.conditionalExpressionDepth -= 1;
         }
       }
-      parseArrowFunctionBody() {
+      parseArrowFunctionBody(params) {
         if (this.currentToken().type === "punctuator" && this.currentToken().value === "{") {
-          return this.withFunctionContext(false, () => this.parseBlockStatement());
+          return this.withFunctionContext(false, () => this.parseBlockStatement(params));
         }
         return this.withFunctionContext(false, () => this.parseExpression().node);
       }
-      parseBlockStatement() {
+      parseBlockStatement(params, catchParam) {
         const start = this.expectPunctuator("{");
-        return this.withScope(() => this.parseBlockStatementBody(start));
+        return this.withScope(() => {
+          for (const param of params ?? []) {
+            for (const identifier of boundIdentifiers(param)) {
+              this.declareBinding(identifier, "parameter");
+            }
+          }
+          if (catchParam !== void 0) {
+            for (const identifier of boundIdentifiers(catchParam)) {
+              this.declareBinding(identifier, catchParam.type === "Identifier" ? "catch" : "lexical");
+            }
+          }
+          return this.parseBlockStatementBody(start);
+        }, params !== void 0);
       }
       parseBlockStatementBody(start) {
         const body = [];
@@ -122266,7 +122358,7 @@ var init_parser3 = __esm({
           param = this.parseBindingTarget();
           this.expectPunctuator(")");
         }
-        const body = this.parseBlockStatement();
+        const body = this.parseBlockStatement(void 0, param);
         return {
           type: "CatchClause",
           param,
@@ -122285,6 +122377,10 @@ var init_parser3 = __esm({
           const declarator = this.parseVariableDeclarator(kindToken.value);
           if (kindToken.value !== "var") {
             this.declarePatternBindings(declarator.id);
+          } else {
+            for (const identifier of boundIdentifiers(declarator.id)) {
+              this.declareVarBinding(identifier);
+            }
           }
           declarations.push(declarator);
           const comma = this.consumePunctuator(",");
@@ -122309,18 +122405,18 @@ var init_parser3 = __esm({
           );
         }
         const id = this.parseBindingIdentifier();
-        this.declareBinding(id);
+        this.declareBinding(id, "function");
         const params = this.withScope(() => {
           const parsedParams = this.parseArrowParameters();
           for (const param of parsedParams) {
-            for (const identifier of collectBindingIdentifiers(param)) {
+            for (const identifier of boundIdentifiers(param)) {
               this.declareBinding(identifier);
             }
           }
           return parsedParams;
         });
         const generator = generatorToken !== void 0;
-        const body = this.withFunctionContext(generator, () => this.parseBlockStatement());
+        const body = this.withFunctionContext(generator, () => this.parseBlockStatement(params));
         return {
           type: "FunctionDeclaration",
           async: asyncToken !== void 0,
@@ -123279,14 +123375,14 @@ var init_parser3 = __esm({
         const params = this.withScope(() => {
           const parsedParams = this.parseArrowParameters();
           for (const param of parsedParams) {
-            for (const identifier of collectBindingIdentifiers(param)) {
+            for (const identifier of boundIdentifiers(param)) {
               this.declareBinding(identifier);
             }
           }
           return parsedParams;
         });
         const generator = generatorToken !== void 0;
-        const body = this.withFunctionContext(generator, () => this.parseBlockStatement());
+        const body = this.withFunctionContext(generator, () => this.parseBlockStatement(params));
         return {
           type: "FunctionExpression",
           async: asyncToken !== void 0,
@@ -123522,13 +123618,13 @@ var init_parser3 = __esm({
         const params = this.withScope(() => {
           const parsedParams = this.parseArrowParameters();
           for (const param of parsedParams) {
-            for (const identifier of collectBindingIdentifiers(param)) {
+            for (const identifier of boundIdentifiers(param)) {
               this.declareBinding(identifier);
             }
           }
           return parsedParams;
         });
-        const body = this.withFunctionContext(false, () => this.parseBlockStatement());
+        const body = this.withFunctionContext(false, () => this.parseBlockStatement(params));
         return {
           type: "FunctionExpression",
           async: asyncToken !== void 0,
@@ -123966,8 +124062,10 @@ var init_parser3 = __esm({
           this.breakableDepth -= 1;
         }
       }
-      withScope(callback) {
-        this.scopes.push(/* @__PURE__ */ new Map());
+      withScope(callback, functionBody = false) {
+        const scope = /* @__PURE__ */ new Map();
+        if (functionBody) this.functionScopes.add(scope);
+        this.scopes.push(scope);
         try {
           return callback();
         } finally {
@@ -123975,21 +124073,41 @@ var init_parser3 = __esm({
         }
       }
       declarePatternBindings(pattern) {
-        for (const identifier of collectBindingIdentifiers(pattern)) {
+        for (const identifier of boundIdentifiers(pattern)) {
           this.declareBinding(identifier);
         }
       }
-      declareBinding(identifier) {
+      declareBinding(identifier, kind = "lexical") {
         const scope = this.scopes[this.scopes.length - 1];
         if (scope === void 0) {
           return;
         }
-        if (scope.has(identifier.name)) {
+        const existing = scope.get(identifier.name);
+        const variableFunction = kind === "function" && this.functionScopes.has(scope);
+        if (existing !== void 0 && !(variableFunction && (existing === "function" || existing === "parameter")) || !variableFunction && this.varNames.get(scope)?.has(identifier.name)) {
           throw new Error(
             `Cannot redeclare binding '${identifier.name}' at line ${identifier.span.start.line}, column ${identifier.span.start.column}.`
           );
         }
-        scope.set(identifier.name, identifier.span.start);
+        scope.set(identifier.name, kind);
+      }
+      declareVarBinding(identifier) {
+        for (let index = this.scopes.length - 1; index >= 0; index--) {
+          const scope = this.scopes[index];
+          const existing = scope.get(identifier.name);
+          if (existing === "lexical" || existing === "function" && !this.functionScopes.has(scope)) {
+            throw new Error(
+              `Cannot redeclare binding '${identifier.name}' at line ${identifier.span.start.line}, column ${identifier.span.start.column}.`
+            );
+          }
+          let names = this.varNames.get(scope);
+          if (names === void 0) {
+            names = /* @__PURE__ */ new Set();
+            this.varNames.set(scope, names);
+          }
+          names.add(identifier.name);
+          if (this.functionScopes.has(scope)) return;
+        }
       }
       consumePunctuator(value) {
         const token = this.currentToken();
@@ -124414,7 +124532,7 @@ var init_AS001 = __esm({
               braceContextStack,
               nextSignificantChar
             );
-            if (canStartStatement && nextSignificantChar === ":" && !this.isLoopLabelStart()) {
+            if (canStartStatement && nextSignificantChar === ":" && token.value !== "default" && !this.isLoopLabelStart()) {
               this.report(
                 "label",
                 token.start,
@@ -124472,9 +124590,6 @@ var init_AS001 = __esm({
           case "class":
           case "eval":
           case "Function":
-          case "switch":
-          case "this":
-          case "var":
           case "with":
             this.report(token.value, token.start, token.end);
             return;
@@ -124858,6 +124973,7 @@ var init_AS003 = __esm({
     "use strict";
     init_parser3();
     init_known_globals();
+    init_bindings();
     AS003Scanner = class {
       constructor(filename, allowedGlobals) {
         this.filename = filename;
@@ -124907,6 +125023,9 @@ var init_AS003 = __esm({
           case "TryStatement":
             this.visitTryStatement(node);
             return;
+          case "SwitchStatement":
+            this.visitSwitchStatement(node);
+            return;
           case "VariableDeclaration":
             this.visitVariableDeclaration(node);
             return;
@@ -124930,8 +125049,14 @@ var init_AS003 = __esm({
             return;
         }
       }
-      visitBlock(node) {
-        this.withScope(this.collectBlockBindings(node.body), () => {
+      visitBlock(node, functionBody = false) {
+        const bindings = this.collectBlockBindings(node.body);
+        if (functionBody) {
+          for (const declaration of hoistedVarDeclarations(node.body)) {
+            bindings.push(...this.collectDeclarationBindings(declaration));
+          }
+        }
+        this.withScope(bindings, () => {
           for (const statement of node.body) {
             this.visitStatement(statement);
           }
@@ -124948,7 +125073,7 @@ var init_AS003 = __esm({
         }
       }
       visitForStatement(node) {
-        const bindings = node.init?.type === "VariableDeclaration" ? this.collectDeclarationBindings(node.init) : [];
+        const bindings = node.init?.type === "VariableDeclaration" && node.init.kind !== "var" ? this.collectDeclarationBindings(node.init) : [];
         this.withScope(bindings, () => {
           if (node.init !== void 0) {
             if (node.init.type === "VariableDeclaration") {
@@ -124967,7 +125092,7 @@ var init_AS003 = __esm({
         });
       }
       visitForOfStatement(node) {
-        const bindings = node.left.type === "VariableDeclaration" ? this.collectDeclarationBindings(node.left) : [];
+        const bindings = node.left.type === "VariableDeclaration" && node.left.kind !== "var" ? this.collectDeclarationBindings(node.left) : [];
         this.withScope(bindings, () => {
           if (node.left.type === "VariableDeclaration") {
             this.visitVariableDeclaration(node.left);
@@ -124982,6 +125107,18 @@ var init_AS003 = __esm({
         this.visitExpression(node.test);
         this.visitStatement(node.body);
       }
+      visitSwitchStatement(node) {
+        this.visitExpression(node.discriminant);
+        this.withScope(
+          this.collectBlockBindings(node.cases.flatMap((switchCase) => switchCase.consequent)),
+          () => {
+            for (const switchCase of node.cases) {
+              if (switchCase.test !== void 0) this.visitExpression(switchCase.test);
+              for (const statement of switchCase.consequent) this.visitStatement(statement);
+            }
+          }
+        );
+      }
       visitTryStatement(node) {
         this.visitBlock(node.block);
         if (node.handler !== void 0) {
@@ -125055,8 +125192,19 @@ var init_AS003 = __esm({
             this.visitAssignmentExpression(node);
             return;
           case "CallExpression":
+          case "NewExpression":
             this.visitCallExpression(node);
             return;
+          case "SequenceExpression":
+            for (const expression of node.expressions) this.visitExpression(expression);
+            return;
+          case "UpdateExpression":
+            this.visitExpression(node.argument);
+            return;
+          case "TaggedTemplateExpression":
+            this.visitExpression(node.tag);
+            this.visitTemplateLiteral(node.quasi);
+            return;
           case "TemplateLiteral":
             this.visitTemplateLiteral(node);
             return;
@@ -125074,7 +125222,7 @@ var init_AS003 = __esm({
             this.visitBindingElement(parameter);
           }
           if (node.body.type === "BlockStatement") {
-            this.visitBlock(node.body);
+            this.visitBlock(node.body, true);
           } else {
             this.visitExpression(node.body);
           }
@@ -125288,6 +125436,9 @@ var init_AS003 = __esm({
       }
       collectModuleBindings(body) {
         const bindings = [];
+        for (const declaration of hoistedVarDeclarations(body)) {
+          bindings.push(...this.collectDeclarationBindings(declaration));
+        }
         for (const statement of body) {
           if (statement.type === "ImportDeclaration") {
             bindings.push(...this.collectImportBindings(statement));
@@ -125297,7 +125448,7 @@ var init_AS003 = __esm({
             bindings.push({ kind: "let", name: statement.id.name });
             continue;
           }
-          if (statement.type === "VariableDeclaration") {
+          if (statement.type === "VariableDeclaration" && statement.kind !== "var") {
             bindings.push(...this.collectDeclarationBindings(statement));
             continue;
           }
@@ -125313,7 +125464,7 @@ var init_AS003 = __esm({
           if (statement.type === "FunctionDeclaration") {
             bindings.push({ kind: "let", name: statement.id.name });
           }
-          if (statement.type === "VariableDeclaration") {
+          if (statement.type === "VariableDeclaration" && statement.kind !== "var") {
             bindings.push(...this.collectDeclarationBindings(statement));
           }
         }
@@ -125586,6 +125737,7 @@ var init_AS006_007 = __esm({
   "packages/safejs/src/lint/rules/AS006-007.ts"() {
     "use strict";
     init_parser3();
+    init_bindings();
     AS006007Scanner = class {
       constructor(filename) {
         this.filename = filename;
@@ -125642,6 +125794,9 @@ var init_AS006_007 = __esm({
           case "TryStatement":
             this.visitTryStatement(node);
             return;
+          case "SwitchStatement":
+            this.visitSwitchStatement(node);
+            return;
           case "VariableDeclaration":
             this.visitVariableDeclaration(node);
             return;
@@ -125659,8 +125814,14 @@ var init_AS006_007 = __esm({
             return;
         }
       }
-      visitBlock(node) {
-        this.withScope(this.collectBlockBindings(node.body), () => {
+      visitBlock(node, functionBody = false) {
+        const bindings = this.collectBlockBindings(node.body);
+        if (functionBody) {
+          for (const declaration of hoistedVarDeclarations(node.body)) {
+            bindings.push(...this.collectDeclarationBindings(declaration));
+          }
+        }
+        this.withScope(bindings, () => {
           for (const statement of node.body) {
             this.visitStatement(statement);
           }
@@ -125674,7 +125835,7 @@ var init_AS006_007 = __esm({
         }
       }
       visitForStatement(node) {
-        const bindings = node.init?.type === "VariableDeclaration" ? this.collectDeclarationBindings(node.init) : [];
+        const bindings = node.init?.type === "VariableDeclaration" && node.init.kind !== "var" ? this.collectDeclarationBindings(node.init) : [];
         this.withScope(bindings, () => {
           if (node.init !== void 0) {
             if (node.init.type === "VariableDeclaration") {
@@ -125693,7 +125854,7 @@ var init_AS006_007 = __esm({
         });
       }
       visitForOfStatement(node) {
-        const bindings = node.left.type === "VariableDeclaration" ? this.collectDeclarationBindings(node.left) : [];
+        const bindings = node.left.type === "VariableDeclaration" && node.left.kind !== "var" ? this.collectDeclarationBindings(node.left) : [];
         this.withScope(bindings, () => {
           if (node.left.type === "VariableDeclaration") {
             this.visitVariableDeclaration(node.left);
@@ -125725,6 +125886,16 @@ var init_AS006_007 = __esm({
           this.visitBlock(node.body);
         });
       }
+      visitSwitchStatement(node) {
+        this.visitExpression(node.discriminant);
+        const statements = node.cases.flatMap((switchCase) => switchCase.consequent);
+        this.withScope(this.collectBlockBindings(statements), () => {
+          for (const switchCase of node.cases) {
+            if (switchCase.test !== void 0) this.visitExpression(switchCase.test);
+            for (const statement of switchCase.consequent) this.visitStatement(statement);
+          }
+        });
+      }
       visitThrowStatement(node) {
         this.visitExpression(node.argument);
       }
@@ -125784,8 +125955,19 @@ var init_AS006_007 = __esm({
             this.visitAssignmentExpression(node);
             return;
           case "CallExpression":
+          case "NewExpression":
             this.visitCallExpression(node);
             return;
+          case "SequenceExpression":
+            for (const expression of node.expressions) this.visitExpression(expression);
+            return;
+          case "UpdateExpression":
+            this.visitExpression(node.argument);
+            return;
+          case "TaggedTemplateExpression":
+            this.visitExpression(node.tag);
+            this.visitTemplateLiteral(node.quasi);
+            return;
           case "TemplateLiteral":
             this.visitTemplateLiteral(node);
             return;
@@ -125804,7 +125986,7 @@ var init_AS006_007 = __esm({
               this.visitBindingElement(parameter);
             }
             if (node.body.type === "BlockStatement") {
-              this.visitBlock(node.body);
+              this.visitBlock(node.body, true);
               return;
             }
             this.visitExpression(node.body);
@@ -126021,6 +126203,9 @@ var init_AS006_007 = __esm({
       }
       collectModuleBindings(body) {
         const bindings = [];
+        for (const declaration of hoistedVarDeclarations(body)) {
+          bindings.push(...this.collectDeclarationBindings(declaration));
+        }
         for (const statement of body) {
           if (statement.type === "ImportDeclaration") {
             bindings.push(...this.collectImportBindings(statement));
@@ -126030,7 +126215,7 @@ var init_AS006_007 = __esm({
             bindings.push(this.createBinding(statement.id, "let"));
             continue;
           }
-          if (statement.type === "VariableDeclaration") {
+          if (statement.type === "VariableDeclaration" && statement.kind !== "var") {
             bindings.push(...this.collectDeclarationBindings(statement));
             continue;
           }
@@ -126046,7 +126231,7 @@ var init_AS006_007 = __esm({
           if (statement.type === "FunctionDeclaration") {
             bindings.push(this.createBinding(statement.id, "let"));
           }
-          if (statement.type === "VariableDeclaration") {
+          if (statement.type === "VariableDeclaration" && statement.kind !== "var") {
             bindings.push(...this.collectDeclarationBindings(statement));
           }
         }
@@ -126201,406 +126386,16 @@ var init_AS006_007 = __esm({
   }
 });
 
-// packages/safejs/src/lint/rules/AS008.ts
-function AS008(source, options = {}) {
-  return new AS008Scanner(options.filename ?? "<input>").scan(source);
-}
-var MESSAGE, AS008Scanner;
-var init_AS008 = __esm({
-  "packages/safejs/src/lint/rules/AS008.ts"() {
-    "use strict";
-    init_parser3();
-    MESSAGE = "Await is only allowed at the script top level or inside async arrow functions.";
-    AS008Scanner = class {
-      constructor(filename) {
-        this.filename = filename;
-      }
-      filename;
-      diagnostics = [];
-      functionStack = [];
-      scopeDepth = 0;
-      scan(source) {
-        const module = parseModule(source, this.filename);
-        this.visitModule(module);
-        return this.diagnostics;
-      }
-      visitModule(node) {
-        for (const statement of node.body) {
-          this.visitStatement(statement);
-        }
-      }
-      visitStatement(node) {
-        switch (node.type) {
-          case "FunctionDeclaration":
-            this.visitArrowFunction(node);
-            return;
-          case "BlockStatement":
-            this.withNestedScope(() => {
-              this.visitBlock(node);
-            });
-            return;
-          case "ExpressionStatement":
-            this.visitExpression(node.expression);
-            return;
-          case "IfStatement":
-            this.visitIfStatement(node);
-            return;
-          case "ForStatement":
-            this.visitForStatement(node);
-            return;
-          case "ForInStatement":
-          case "ForOfStatement":
-            this.visitForOfStatement(node);
-            return;
-          case "WhileStatement":
-          case "DoWhileStatement":
-            this.visitWhileStatement(node);
-            return;
-          case "TryStatement":
-            this.visitTryStatement(node);
-            return;
-          case "VariableDeclaration":
-            this.visitVariableDeclaration(node);
-            return;
-          case "ReturnStatement":
-            if (node.argument !== void 0) {
-              this.visitExpression(node.argument);
-            }
-            return;
-          case "ThrowStatement":
-            this.visitThrowStatement(node);
-            return;
-          case "ImportDeclaration":
-          case "BreakStatement":
-          case "ContinueStatement":
-            return;
-        }
-      }
-      visitBlock(node) {
-        for (const statement of node.body) {
-          this.visitStatement(statement);
-        }
-      }
-      visitIfStatement(node) {
-        this.visitExpression(node.test);
-        this.visitStatement(node.consequent);
-        if (node.alternate !== void 0) {
-          this.visitStatement(node.alternate);
-        }
-      }
-      visitForStatement(node) {
-        if (node.init !== void 0) {
-          if (node.init.type === "VariableDeclaration") {
-            this.visitVariableDeclaration(node.init);
-          } else {
-            this.visitExpression(node.init);
-          }
-        }
-        if (node.test !== void 0) {
-          this.visitExpression(node.test);
-        }
-        if (node.update !== void 0) {
-          this.visitExpression(node.update);
-        }
-        this.visitStatement(node.body);
-      }
-      visitForOfStatement(node) {
-        if (node.left.type === "VariableDeclaration") {
-          this.visitVariableDeclaration(node.left);
-        } else {
-          this.visitAssignmentTarget(node.left);
-        }
-        this.visitExpression(node.right);
-        this.visitStatement(node.body);
-      }
-      visitWhileStatement(node) {
-        this.visitExpression(node.test);
-        this.visitStatement(node.body);
-      }
-      visitTryStatement(node) {
-        this.visitStatement(node.block);
-        if (node.handler !== void 0) {
-          this.visitCatchClause(node.handler);
-        }
-        if (node.finalizer !== void 0) {
-          this.visitStatement(node.finalizer);
-        }
-      }
-      visitCatchClause(node) {
-        this.withNestedScope(() => {
-          if (node.param !== void 0) {
-            this.visitBindingPattern(node.param);
-          }
-          this.visitBlock(node.body);
-        });
-      }
-      visitThrowStatement(node) {
-        this.visitExpression(node.argument);
-      }
-      visitVariableDeclaration(node) {
-        for (const declarator of node.declarations) {
-          this.visitVariableDeclarator(declarator);
-        }
-      }
-      visitVariableDeclarator(node) {
-        this.visitBindingPattern(node.id);
-        if (node.init !== void 0) {
-          this.visitExpression(node.init);
-        }
-      }
-      visitExpression(node) {
-        switch (node.type) {
-          case "YieldExpression":
-            if (node.argument !== void 0) {
-              this.visitExpression(node.argument);
-            }
-            return;
-          case "FunctionExpression":
-          case "ArrowFunctionExpression":
-            this.visitArrowFunction(node);
-            return;
-          case "AwaitExpression":
-            this.visitAwaitExpression(node);
-            return;
-          case "ArrayExpression":
-            this.visitArrayExpression(node);
-            return;
-          case "ObjectExpression":
-            this.visitObjectExpression(node);
-            return;
-          case "UnaryExpression":
-            this.visitUnaryExpression(node);
-            return;
-          case "BinaryExpression":
-            this.visitBinaryExpression(node);
-            return;
-          case "LogicalExpression":
-            this.visitLogicalExpression(node);
-            return;
-          case "ConditionalExpression":
-            this.visitConditionalExpression(node);
-            return;
-          case "MemberExpression":
-            this.visitMemberExpression(node);
-            return;
-          case "AssignmentExpression":
-            this.visitAssignmentExpression(node);
-            return;
-          case "CallExpression":
-            this.visitCallExpression(node);
-            return;
-          case "TemplateLiteral":
-            this.visitTemplateLiteral(node);
-            return;
-          case "Identifier":
-          case "BooleanLiteral":
-          case "NullLiteral":
-          case "NumericLiteral":
-          case "StringLiteral":
-          case "UndefinedLiteral":
-            return;
-        }
-      }
-      visitArrowFunction(node) {
-        this.functionStack.push(node.async);
-        for (const parameter of node.params) {
-          this.visitBindingElement(parameter);
-        }
-        const body = node.body;
-        if (body.type === "BlockStatement") {
-          this.withNestedScope(() => {
-            this.visitBlock(body);
-          });
-        } else {
-          this.visitExpression(body);
-        }
-        this.functionStack.pop();
-      }
-      visitAwaitExpression(node) {
-        if (!this.isAwaitAllowed()) {
-          this.diagnostics.push({
-            code: "AS008",
-            severity: "error",
-            message: MESSAGE,
-            filename: this.filename,
-            line: node.span.start.line,
-            column: node.span.start.column,
-            span: node.span
-          });
-        }
-        this.visitExpression(node.argument);
-      }
-      visitArrayExpression(node) {
-        for (const element of node.elements) {
-          if (element?.type === "SpreadElement") {
-            this.visitSpreadElement(element);
-            continue;
-          }
-          if (element !== void 0) {
-            this.visitExpression(element);
-          }
-        }
-      }
-      visitObjectExpression(node) {
-        for (const property of node.properties) {
-          if (property.type === "SpreadElement") {
-            this.visitSpreadElement(property);
-            continue;
-          }
-          this.visitProperty(property);
-        }
-      }
-      visitUnaryExpression(node) {
-        this.visitExpression(node.argument);
-      }
-      visitBinaryExpression(node) {
-        this.visitExpression(node.left);
-        this.visitExpression(node.right);
-      }
-      visitLogicalExpression(node) {
-        this.visitExpression(node.left);
-        this.visitExpression(node.right);
-      }
-      visitConditionalExpression(node) {
-        this.visitExpression(node.test);
-        this.visitExpression(node.consequent);
-        this.visitExpression(node.alternate);
-      }
-      visitMemberExpression(node) {
-        this.visitExpression(node.object);
-        if (node.computed) {
-          this.visitExpression(node.property);
-        }
-      }
-      visitAssignmentExpression(node) {
-        this.visitAssignmentTarget(node.left);
-        this.visitExpression(node.right);
-      }
-      visitCallExpression(node) {
-        this.visitExpression(node.callee);
-        for (const argument of node.arguments) {
-          if (argument.type === "SpreadElement") {
-            this.visitSpreadElement(argument);
-            continue;
-          }
-          this.visitExpression(argument);
-        }
-      }
-      visitTemplateLiteral(node) {
-        for (const expression of node.expressions) {
-          this.visitExpression(expression);
-        }
-      }
-      visitProperty(node) {
-        if (node.computed) {
-          this.visitExpression(node.key);
-        }
-        this.visitExpression(node.value);
-      }
-      visitSpreadElement(node) {
-        this.visitExpression(node.argument);
-      }
-      visitAssignmentTarget(node) {
-        if (node.type === "Identifier") {
-          return;
-        }
-        if (node.type === "MetaProperty") {
-          return;
-        }
-        if (node.type === "MemberExpression") {
-          this.visitMemberExpression(node);
-          return;
-        }
-        this.visitBindingPattern(node);
-      }
-      visitBindingElement(node) {
-        if (node.type === "RestElement") {
-          this.visitRestElement(node);
-          return;
-        }
-        this.visitBindingPattern(node);
-      }
-      visitBindingPattern(node) {
-        switch (node.type) {
-          case "Identifier":
-            return;
-          case "MemberExpression":
-            this.visitMemberExpression(node);
-            return;
-          case "AssignmentPattern":
-            this.visitAssignmentPattern(node);
-            return;
-          case "ArrayPattern":
-            this.visitArrayPattern(node);
-            return;
-          case "ObjectPattern":
-            this.visitObjectPattern(node);
-            return;
-        }
-      }
-      visitAssignmentPattern(node) {
-        this.visitBindingPattern(node.left);
-        this.visitExpression(node.right);
-      }
-      visitArrayPattern(node) {
-        for (const element of node.elements) {
-          if (element === null) {
-            continue;
-          }
-          if (element.type === "RestElement") {
-            this.visitRestElement(element);
-            continue;
-          }
-          this.visitBindingPattern(element);
-        }
-      }
-      visitObjectPattern(node) {
-        for (const property of node.properties) {
-          if (property.type === "RestElement") {
-            this.visitRestElement(property);
-            continue;
-          }
-          this.visitAssignmentProperty(property);
-        }
-      }
-      visitAssignmentProperty(node) {
-        if (node.computed) {
-          this.visitExpression(node.key);
-        }
-        this.visitBindingPattern(node.value);
-      }
-      visitRestElement(node) {
-        this.visitAssignmentTarget(node.argument);
-      }
-      isAwaitAllowed() {
-        const currentFunction = this.functionStack.at(-1);
-        if (currentFunction !== void 0) {
-          return true;
-        }
-        return this.scopeDepth === 0;
-      }
-      withNestedScope(callback) {
-        this.scopeDepth += 1;
-        try {
-          callback();
-        } finally {
-          this.scopeDepth -= 1;
-        }
-      }
-    };
-  }
-});
-
 // packages/safejs/src/lint/rules/AS009.ts
 function AS009(source, options = {}) {
   return new AS009Scanner(options.filename ?? "<input>").scan(source);
 }
-var MESSAGE2, AS009Scanner;
+var MESSAGE, AS009Scanner;
 var init_AS009 = __esm({
   "packages/safejs/src/lint/rules/AS009.ts"() {
     "use strict";
     init_parser3();
-    MESSAGE2 = "Async arrow returns a host call without awaiting it. Add 'await' or document that this function intentionally returns a Promise.";
+    MESSAGE = "Async arrow returns a host call without awaiting it. Add 'await' or document that this function intentionally returns a Promise.";
     AS009Scanner = class {
       constructor(filename) {
         this.filename = filename;
@@ -126950,7 +126745,7 @@ var init_AS009 = __esm({
         this.diagnostics.push({
           code: "AS009",
           severity: "error",
-          message: MESSAGE2,
+          message: MESSAGE,
           filename: this.filename,
           line: node.span.start.line,
           column: node.span.start.column,
@@ -127746,13 +127541,13 @@ var init_AS010 = __esm({
 function AS011(source, options = {}) {
   return new AS011Scanner(options.filename ?? "<input>").scan(source);
 }
-var FORBIDDEN_PROPERTY_NAMES, MESSAGE3, AS011Scanner;
+var FORBIDDEN_PROPERTY_NAMES, MESSAGE2, AS011Scanner;
 var init_AS011 = __esm({
   "packages/safejs/src/lint/rules/AS011.ts"() {
     "use strict";
     init_parser3();
     FORBIDDEN_PROPERTY_NAMES = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
-    MESSAGE3 = "Property access to '__proto__', 'prototype', and 'constructor' is not allowed.";
+    MESSAGE2 = "Property access to '__proto__', 'prototype', and 'constructor' is not allowed.";
     AS011Scanner = class {
       constructor(filename) {
         this.filename = filename;
@@ -128074,7 +127869,7 @@ var init_AS011 = __esm({
         this.diagnostics.push({
           code: "AS011",
           severity: "error",
-          message: MESSAGE3,
+          message: MESSAGE2,
           filename: this.filename,
           line: span.start.line,
           column: span.start.column,
@@ -129052,314 +128847,6 @@ var init_AS_async_not_needed = __esm({
   }
 });
 
-// packages/safejs/src/lint/rules/AS-await-non-promise.ts
-function AS_AWAIT_NON_PROMISE(source, options = {}) {
-  return new ASAwaitNonPromiseScanner(options.filename ?? "<input>").scan(source);
-}
-function isKnownNonPromiseExpression(node) {
-  switch (node.type) {
-    case "FunctionExpression":
-    case "ArrowFunctionExpression":
-    case "ArrayExpression":
-    case "BinaryExpression":
-    case "BooleanLiteral":
-    case "NullLiteral":
-    case "NumericLiteral":
-    case "ObjectExpression":
-    case "StringLiteral":
-    case "TemplateLiteral":
-    case "UnaryExpression":
-      return true;
-    default:
-      return false;
-  }
-}
-var ASAwaitNonPromiseScanner;
-var init_AS_await_non_promise = __esm({
-  "packages/safejs/src/lint/rules/AS-await-non-promise.ts"() {
-    "use strict";
-    init_parser3();
-    ASAwaitNonPromiseScanner = class {
-      constructor(filename) {
-        this.filename = filename;
-      }
-      filename;
-      diagnostics = [];
-      scan(source) {
-        this.visitModule(parseModule(source, this.filename));
-        return this.diagnostics;
-      }
-      visitModule(node) {
-        for (const statement of node.body) {
-          this.visitStatement(statement);
-        }
-      }
-      visitStatement(node) {
-        switch (node.type) {
-          case "FunctionDeclaration":
-            this.visitArrowFunction(node);
-            return;
-          case "BlockStatement":
-            this.visitBlockStatement(node);
-            return;
-          case "ExpressionStatement":
-            this.visitExpression(node.expression);
-            return;
-          case "IfStatement":
-            this.visitIfStatement(node);
-            return;
-          case "ForStatement":
-            this.visitForStatement(node);
-            return;
-          case "ForInStatement":
-          case "ForOfStatement":
-            this.visitForOfStatement(node);
-            return;
-          case "WhileStatement":
-          case "DoWhileStatement":
-            this.visitWhileStatement(node);
-            return;
-          case "TryStatement":
-            this.visitTryStatement(node);
-            return;
-          case "VariableDeclaration":
-            this.visitVariableDeclaration(node);
-            return;
-          case "ReturnStatement":
-            this.visitReturnStatement(node);
-            return;
-          case "ThrowStatement":
-            this.visitThrowStatement(node);
-            return;
-          case "ExportNamedDeclaration":
-            this.visitVariableDeclaration(node.declaration);
-            return;
-          case "ExportDefaultDeclaration":
-            this.visitExpression(node.declaration);
-            return;
-          case "ImportDeclaration":
-          case "BreakStatement":
-          case "ContinueStatement":
-            return;
-        }
-      }
-      visitBlockStatement(node) {
-        for (const statement of node.body) {
-          this.visitStatement(statement);
-        }
-      }
-      visitIfStatement(node) {
-        this.visitExpression(node.test);
-        this.visitStatement(node.consequent);
-        if (node.alternate !== void 0) {
-          this.visitStatement(node.alternate);
-        }
-      }
-      visitForStatement(node) {
-        if (node.init !== void 0) {
-          if (node.init.type === "VariableDeclaration") {
-            this.visitVariableDeclaration(node.init);
-          } else {
-            this.visitExpression(node.init);
-          }
-        }
-        if (node.test !== void 0) {
-          this.visitExpression(node.test);
-        }
-        if (node.update !== void 0) {
-          this.visitExpression(node.update);
-        }
-        this.visitStatement(node.body);
-      }
-      visitForOfStatement(node) {
-        if (node.left.type === "VariableDeclaration") {
-          this.visitVariableDeclaration(node.left);
-        }
-        this.visitExpression(node.right);
-        this.visitStatement(node.body);
-      }
-      visitWhileStatement(node) {
-        this.visitExpression(node.test);
-        this.visitStatement(node.body);
-      }
-      visitTryStatement(node) {
-        this.visitBlockStatement(node.block);
-        if (node.handler !== void 0) {
-          this.visitCatchClause(node.handler);
-        }
-        if (node.finalizer !== void 0) {
-          this.visitBlockStatement(node.finalizer);
-        }
-      }
-      visitCatchClause(node) {
-        this.visitBlockStatement(node.body);
-      }
-      visitVariableDeclaration(node) {
-        for (const declarator of node.declarations) {
-          this.visitVariableDeclarator(declarator);
-        }
-      }
-      visitVariableDeclarator(node) {
-        if (node.init !== void 0) {
-          this.visitExpression(node.init);
-        }
-      }
-      visitReturnStatement(node) {
-        if (node.argument !== void 0) {
-          this.visitExpression(node.argument);
-        }
-      }
-      visitThrowStatement(node) {
-        this.visitExpression(node.argument);
-      }
-      visitExpression(node) {
-        switch (node.type) {
-          case "YieldExpression":
-            if (node.argument !== void 0) {
-              this.visitExpression(node.argument);
-            }
-            return;
-          case "FunctionExpression":
-          case "ArrowFunctionExpression":
-            this.visitArrowFunction(node);
-            return;
-          case "AwaitExpression":
-            this.visitAwaitExpression(node);
-            return;
-          case "ArrayExpression":
-            this.visitArrayExpression(node);
-            return;
-          case "ObjectExpression":
-            this.visitObjectExpression(node);
-            return;
-          case "UnaryExpression":
-            this.visitUnaryExpression(node);
-            return;
-          case "BinaryExpression":
-          case "LogicalExpression":
-            this.visitBinaryLikeExpression(node);
-            return;
-          case "ConditionalExpression":
-            this.visitConditionalExpression(node);
-            return;
-          case "MemberExpression":
-            this.visitMemberExpression(node);
-            return;
-          case "AssignmentExpression":
-            this.visitAssignmentExpression(node);
-            return;
-          case "CallExpression":
-            this.visitCallExpression(node);
-            return;
-          case "TemplateLiteral":
-            this.visitTemplateLiteral(node);
-            return;
-          case "TaggedTemplateExpression":
-            this.visitTaggedTemplateExpression(node);
-            return;
-          case "Identifier":
-          case "BooleanLiteral":
-          case "MetaProperty":
-          case "NullLiteral":
-          case "NumericLiteral":
-          case "RegexLiteral":
-          case "StringLiteral":
-          case "UndefinedLiteral":
-            return;
-        }
-      }
-      visitArrowFunction(node) {
-        if (node.body.type === "BlockStatement") {
-          this.visitBlockStatement(node.body);
-          return;
-        }
-        this.visitExpression(node.body);
-      }
-      visitAwaitExpression(node) {
-        if (isKnownNonPromiseExpression(node.argument)) {
-          this.report(node.argument.span);
-        }
-        this.visitExpression(node.argument);
-      }
-      visitArrayExpression(node) {
-        for (const element of node.elements) {
-          if (element.type === "SpreadElement") {
-            this.visitExpression(element.argument);
-            continue;
-          }
-          this.visitExpression(element);
-        }
-      }
-      visitObjectExpression(node) {
-        for (const property of node.properties) {
-          if (property.type === "SpreadElement") {
-            this.visitExpression(property.argument);
-            continue;
-          }
-          this.visitProperty(property);
-        }
-      }
-      visitProperty(node) {
-        if (node.computed) {
-          this.visitExpression(node.key);
-        }
-        this.visitExpression(node.value);
-      }
-      visitUnaryExpression(node) {
-        this.visitExpression(node.argument);
-      }
-      visitBinaryLikeExpression(node) {
-        this.visitExpression(node.left);
-        this.visitExpression(node.right);
-      }
-      visitConditionalExpression(node) {
-        this.visitExpression(node.test);
-        this.visitExpression(node.consequent);
-        this.visitExpression(node.alternate);
-      }
-      visitMemberExpression(node) {
-        this.visitExpression(node.object);
-        if (node.computed) {
-          this.visitExpression(node.property);
-        }
-      }
-      visitAssignmentExpression(node) {
-        this.visitExpression(node.right);
-      }
-      visitCallExpression(node) {
-        this.visitExpression(node.callee);
-        for (const argument of node.arguments) {
-          if (argument.type === "SpreadElement") {
-            this.visitExpression(argument.argument);
-            continue;
-          }
-          this.visitExpression(argument);
-        }
-      }
-      visitTemplateLiteral(node) {
-        for (const expression of node.expressions) {
-          this.visitExpression(expression);
-        }
-      }
-      visitTaggedTemplateExpression(node) {
-        this.visitExpression(node.tag);
-        this.visitTemplateLiteral(node.quasi);
-      }
-      report(span) {
-        this.diagnostics.push({
-          code: "AS-AWAIT-NON-PROMISE",
-          severity: "warning",
-          message: "Awaiting a known non-promise value has no effect.",
-          filename: this.filename,
-          line: span.start.line,
-          column: span.start.column,
-          span
-        });
-      }
-    };
-  }
-});
-
 // packages/safejs/src/lint/rules/AS-destructure-null-default.ts
 function AS_DESTRUCTURE_NULL_DEFAULT(source, options = {}) {
   return new ASDestructureNullDefaultScanner(options.filename ?? "<input>").scan(source);
@@ -129403,12 +128890,12 @@ function getStaticPropertyKey(key3) {
       return void 0;
   }
 }
-var MESSAGE4, HINT, ASDestructureNullDefaultScanner;
+var MESSAGE3, HINT, ASDestructureNullDefaultScanner;
 var init_AS_destructure_null_default = __esm({
   "packages/safejs/src/lint/rules/AS-destructure-null-default.ts"() {
     "use strict";
     init_parser3();
-    MESSAGE4 = "Destructuring default values only apply to undefined, not null.";
+    MESSAGE3 = "Destructuring default values only apply to undefined, not null.";
     HINT = "Handle null explicitly before destructuring or use ?? after binding.";
     ASDestructureNullDefaultScanner = class {
       constructor(filename) {
@@ -129800,7 +129287,7 @@ var init_AS_destructure_null_default = __esm({
         this.diagnostics.push({
           code: "AS-DESTRUCTURE-NULL-DEFAULT",
           severity: "warning",
-          message: MESSAGE4,
+          message: MESSAGE3,
           filename: this.filename,
           line: span.start.line,
           column: span.start.column,
@@ -134417,12 +133904,12 @@ function bodyHasExit(node, exitingLabels, allowUnlabeledBreak) {
       return false;
   }
 }
-var MESSAGE5, ASUnboundedLoopScanner;
+var MESSAGE4, ASUnboundedLoopScanner;
 var init_AS_unbounded_loop = __esm({
   "packages/safejs/src/lint/rules/AS-unbounded-loop.ts"() {
     "use strict";
     init_parser3();
-    MESSAGE5 = "Unbounded loop or generator source has no static exit with break, return, or throw.";
+    MESSAGE4 = "Unbounded loop or generator source has no static exit with break, return, or throw.";
     ASUnboundedLoopScanner = class {
       constructor(filename) {
         this.filename = filename;
@@ -134720,7 +134207,7 @@ var init_AS_unbounded_loop = __esm({
         this.diagnostics.push({
           code: "AS-UNBOUNDED-LOOP",
           severity: "warning",
-          message: MESSAGE5,
+          message: MESSAGE4,
           filename: this.filename,
           line: node.span.start.line,
           column: node.span.start.column,
@@ -135994,14 +135481,12 @@ var init_lint3 = __esm({
     init_AS004();
     init_AS005();
     init_AS006_007();
-    init_AS008();
     init_AS009();
     init_AS010();
     init_AS011();
     init_AS013();
     init_AS015();
     init_AS_async_not_needed();
-    init_AS_await_non_promise();
     init_AS_destructure_null_default();
     init_AS_export_import_meta();
     init_AS_floating_promise();
@@ -136026,14 +135511,12 @@ var init_lint3 = __esm({
       AS_UNUSED_IMPORT,
       AS006_007,
       AS_MISSING_ASYNC,
-      AS008,
       AS009,
       AS010,
       AS011,
       AS013,
       AS015,
       AS_IMPORT_CYCLE,
-      AS_AWAIT_NON_PROMISE,
       AS_FLOATING_PROMISE,
       AS_ASYNC_NOT_NEEDED,
       AS_JSDOC_TYPE,
@@ -137035,7 +136518,7 @@ var init_dump_format = __esm({
     init_arguments();
     init_arguments2();
     DUMP_FORMAT_VERSION = 1;
-    EXECUTION_SEMANTICS = "jobs-v2";
+    EXECUTION_SEMANTICS = "jobs-v3";
     SKIP_VALUE = /* @__PURE__ */ Symbol("SafeJS.skip-dump-value");
   }
 });
@@ -141163,7 +140646,7 @@ async function bindPattern2(pattern, value, target, scope, context) {
   }
 }
 function bindIdentifier(pattern, value, target, scope) {
-  if ("assign" in target || target.kind === "var") {
+  if ("assign" in target || target.kind === "var" && target.initialize !== true) {
     if ("assign" in target) {
       const binding = scope.lookup(pattern.name);
       if (!binding.found) {
@@ -141357,136 +140840,18 @@ var init_patterns = __esm({
 
 // packages/safejs/src/interp/var-hoist.ts
 function hoistVarDeclarations(node, scope) {
-  if (node.type === "BlockStatement") {
-    for (const statement of node.body) {
-      hoistVarStatement(statement, scope);
-    }
-    return;
-  }
-  switch (node.type) {
-    case "VariableDeclaration":
-    case "IfStatement":
-    case "ForStatement":
-    case "ForInStatement":
-    case "ForOfStatement":
-    case "WhileStatement":
-    case "DoWhileStatement":
-    case "TryStatement":
-    case "SwitchStatement":
-    case "ExportNamedDeclaration":
-      hoistVarStatement(node, scope);
-      return;
-    default:
-      return;
-  }
-}
-function hoistVarStatement(statement, scope) {
-  switch (statement.type) {
-    case "VariableDeclaration":
-      declareVarBindings(statement, scope);
-      return;
-    case "BlockStatement":
-      hoistVarDeclarations(statement, scope);
-      return;
-    case "IfStatement":
-      hoistVarStatement(statement.consequent, scope);
-      if (statement.alternate !== void 0) {
-        hoistVarStatement(statement.alternate, scope);
-      }
-      return;
-    case "ForStatement":
-      if (statement.init?.type === "VariableDeclaration") {
-        declareVarBindings(statement.init, scope);
-      }
-      hoistVarStatement(statement.body, scope);
-      return;
-    case "ForInStatement":
-    case "ForOfStatement":
-      if (statement.left.type === "VariableDeclaration") {
-        declareVarBindings(statement.left, scope);
-      }
-      hoistVarStatement(statement.body, scope);
-      return;
-    case "WhileStatement":
-    case "DoWhileStatement":
-      hoistVarStatement(statement.body, scope);
-      return;
-    case "TryStatement":
-      hoistVarDeclarations(statement.block, scope);
-      if (statement.handler !== void 0) {
-        hoistVarDeclarations(statement.handler.body, scope);
-      }
-      if (statement.finalizer !== void 0) {
-        hoistVarDeclarations(statement.finalizer, scope);
-      }
-      return;
-    case "SwitchStatement":
-      for (const switchCase of statement.cases) {
-        for (const consequent of switchCase.consequent) {
-          hoistVarStatement(consequent, scope);
-        }
+  for (const declaration of hoistedVarDeclarations([node])) {
+    for (const declarator of declaration.declarations) {
+      for (const identifier of boundIdentifiers(declarator.id)) {
+        scope.declareVar(identifier.name);
       }
-      return;
-    case "ExportNamedDeclaration":
-      hoistVarStatement(statement.declaration, scope);
-      return;
-    case "FunctionDeclaration":
-    case "ExportDefaultDeclaration":
-    case "ImportDeclaration":
-    case "BreakStatement":
-    case "ContinueStatement":
-    case "EmptyStatement":
-    case "ExpressionStatement":
-    case "ReturnStatement":
-    case "ThrowStatement":
-      return;
-  }
-}
-function declareVarBindings(declaration, scope) {
-  if (declaration.kind !== "var") {
-    return;
-  }
-  for (const declarator of declaration.declarations) {
-    for (const name of getPatternBindingNames2(declarator.id)) {
-      scope.declareVar(name);
     }
   }
 }
-function getPatternBindingNames2(pattern) {
-  switch (pattern.type) {
-    case "Identifier":
-      return [pattern.name];
-    case "ArrayPattern":
-      return pattern.elements.flatMap(
-        (element) => element === null || element.type === "MemberExpression" ? [] : getNestedPatternBindingNames(element)
-      );
-    case "ObjectPattern":
-      return pattern.properties.flatMap(
-        (property) => property.type === "RestElement" ? property.argument.type === "MemberExpression" ? [] : getNestedPatternBindingNames(property.argument) : property.value.type === "MemberExpression" ? [] : getNestedPatternBindingNames(property.value)
-      );
-  }
-}
-function getNestedPatternBindingNames(pattern) {
-  switch (pattern.type) {
-    case "Identifier":
-      return [pattern.name];
-    case "AssignmentPattern":
-      return pattern.left.type === "MemberExpression" ? [] : getNestedPatternBindingNames(pattern.left);
-    case "RestElement":
-      return pattern.argument.type === "MemberExpression" ? [] : getNestedPatternBindingNames(pattern.argument);
-    case "ArrayPattern":
-      return pattern.elements.flatMap(
-        (element) => element === null || element.type === "MemberExpression" ? [] : getNestedPatternBindingNames(element)
-      );
-    case "ObjectPattern":
-      return pattern.properties.flatMap(
-        (property) => property.type === "RestElement" ? property.argument.type === "MemberExpression" ? [] : getNestedPatternBindingNames(property.argument) : property.value.type === "MemberExpression" ? [] : getNestedPatternBindingNames(property.value)
-      );
-  }
-}
 var init_var_hoist = __esm({
   "packages/safejs/src/interp/var-hoist.ts"() {
     "use strict";
+    init_bindings();
   }
 });
 
@@ -141609,6 +140974,7 @@ function createGeneratorClosure(node, context, evaluateNode3) {
       const channel = createGeneratorChannel(async (generatorYield) => {
         const result = await evaluateNode3(node.body, {
           ...closureContext,
+          functionBody: node.body,
           generatorYield: (value, yieldNodeId) => {
             generator.state = "suspended";
             return generatorYield(value, yieldNodeId);
@@ -141660,6 +141026,7 @@ async function executeClosure(node, args, thisValue, context, evaluateNode3) {
   const scope = await createClosureScope(node, args, thisValue, context, evaluateNode3);
   const result = await evaluateNode3(node.body, {
     ...context,
+    functionBody: node.body.type === "BlockStatement" ? node.body : void 0,
     scope
   });
   if (result.kind === "error") {
@@ -141681,16 +141048,28 @@ async function createClosureScope(node, args, thisValue, context, evaluateNode3)
     scope.declare("arguments", "let", createSandboxArguments(args));
   }
   await bindParameters(node.params, args, scope, context, evaluateNode3);
-  hoistVarDeclarations(node.body, scope);
-  return scope;
+  const bodyScope = node.params.some(containsParameterExpression) ? scope.child({}, { functionBoundary: true }) : scope;
+  hoistVarDeclarations(node.body, bodyScope);
+  if (bodyScope !== scope) {
+    for (const declaration of hoistedVarDeclarations([node.body])) {
+      for (const declarator of declaration.declarations) {
+        for (const identifier of boundIdentifiers(declarator.id)) {
+          if (!scope.hasOwnBinding(identifier.name)) continue;
+          const parameter = scope.lookup(identifier.name);
+          if (parameter.found) bodyScope.assign(identifier.name, parameter.value);
+        }
+      }
+    }
+  }
+  return bodyScope;
 }
 function isBlockBody(body) {
   return body.type === "BlockStatement";
 }
 async function bindParameters(params, args, scope, context, evaluateNode3) {
   for (const param of params) {
-    for (const name of getParameterBindingNames(param)) {
-      scope.predeclare(name, "let");
+    for (const identifier of boundIdentifiers(param)) {
+      scope.predeclare(identifier.name, "var");
     }
   }
   for (let index = 0; index < params.length; index += 1) {
@@ -141698,7 +141077,7 @@ async function bindParameters(params, args, scope, context, evaluateNode3) {
     if (param.type === "RestElement") {
       const rest = args.slice(index);
       context.budget.allocateArrayLength(rest.length);
-      const binding2 = await bindPattern2(param, rest, { kind: "let" }, scope, {
+      const binding2 = await bindPattern2(param, rest, { kind: "var", initialize: true }, scope, {
         evaluate: (defaultNode) => evaluateNode3(defaultNode, { ...context, scope })
       });
       if (!binding2.ok) {
@@ -141711,9 +141090,15 @@ async function bindParameters(params, args, scope, context, evaluateNode3) {
       }
       return;
     }
-    const binding = await bindPattern2(param, args[index], { kind: "let" }, scope, {
-      evaluate: (defaultNode) => evaluateNode3(defaultNode, { ...context, scope })
-    });
+    const binding = await bindPattern2(
+      param,
+      args[index],
+      { kind: "var", initialize: true },
+      scope,
+      {
+        evaluate: (defaultNode) => evaluateNode3(defaultNode, { ...context, scope })
+      }
+    );
     if (!binding.ok) {
       if (binding.result.kind === "error") {
         throw binding.result.error;
@@ -141724,26 +141109,6 @@ async function bindParameters(params, args, scope, context, evaluateNode3) {
     }
   }
 }
-function getParameterBindingNames(pattern) {
-  switch (pattern.type) {
-    case "Identifier":
-      return [pattern.name];
-    case "MemberExpression":
-      return [];
-    case "AssignmentPattern":
-      return getParameterBindingNames(pattern.left);
-    case "RestElement":
-      return getParameterBindingNames(pattern.argument);
-    case "ArrayPattern":
-      return pattern.elements.flatMap(
-        (element) => element === null ? [] : getParameterBindingNames(element)
-      );
-    case "ObjectPattern":
-      return pattern.properties.flatMap(
-        (property) => property.type === "RestElement" ? getParameterBindingNames(property) : getParameterBindingNames(property.value)
-      );
-  }
-}
 function normalizeClosureResult(result, budget) {
   if (isSandboxPromise(result) && (result.synchronousPrefix !== void 0 || result.hostCall !== void 0)) {
     return result;
@@ -141762,6 +141127,7 @@ var init_async = __esm({
     init_jobs4();
     init_cancel2();
     init_var_hoist();
+    init_bindings();
     init_values();
   }
 });
@@ -145647,7 +145013,7 @@ async function evaluateVariableDeclaration(node, context) {
       continue;
     }
     if (declarator.id.type === "ArrayPattern" || declarator.id.type === "ObjectPattern") {
-      const names = getPatternBindingNames3(declarator.id);
+      const names = getPatternBindingNames2(declarator.id);
       const restoredBindings = [];
       for (const name of names) {
         const restored = context.scope.consumeRestoredBinding(name);
@@ -145718,26 +145084,26 @@ function getForStatementBindingNames(node) {
   return node.init?.type === "VariableDeclaration" && node.init.kind !== "var" ? getDeclarationBindingNames2(node.init) : [];
 }
 function getDeclarationBindingNames2(node) {
-  return node.declarations.flatMap((declarator) => getPatternBindingNames3(declarator.id));
+  return node.declarations.flatMap((declarator) => getPatternBindingNames2(declarator.id));
 }
-function getPatternBindingNames3(pattern) {
+function getPatternBindingNames2(pattern) {
   switch (pattern.type) {
     case "Identifier":
       return [pattern.name];
     case "MemberExpression":
       return [];
     case "AssignmentPattern":
-      return getPatternBindingNames3(pattern.left);
+      return getPatternBindingNames2(pattern.left);
     case "ArrayPattern":
       return pattern.elements.flatMap(
-        (element) => element === null ? [] : getPatternBindingNames3(element)
+        (element) => element === null ? [] : getPatternBindingNames2(element)
       );
     case "ObjectPattern":
       return pattern.properties.flatMap(
-        (property) => property.type === "RestElement" ? getPatternBindingNames3(property) : getPatternBindingNames3(property.value)
+        (property) => property.type === "RestElement" ? getPatternBindingNames2(property) : getPatternBindingNames2(property.value)
       );
     case "RestElement":
-      return getPatternBindingNames3(pattern.argument);
+      return getPatternBindingNames2(pattern.argument);
   }
 }
 async function evaluateBlockStatement(node, context) {
@@ -145807,7 +145173,7 @@ function isParseResult(value) {
   return typeof value === "object" && value !== null && typeof value.type === "string" && Object.hasOwn(value, "span");
 }
 function createBlockContext(node, context) {
-  const scope = node === context.rootNode || context.generatorResume !== void 0 ? context.scope : context.scope.child();
+  const scope = node === context.rootNode || node === context.functionBody || context.generatorResume !== void 0 ? context.scope : context.scope.child();
   const blockContext = {
     ...context,
     scope
@@ -145818,15 +145184,19 @@ function createBlockContext(node, context) {
   return blockContext;
 }
 function predeclareBlockBindings2(node, context) {
-  predeclareStatementListBindings(node.body, context);
+  predeclareStatementListBindings(
+    node.body,
+    context,
+    node === context.functionBody || node === context.rootNode
+  );
 }
-function predeclareStatementListBindings(statements, context) {
+function predeclareStatementListBindings(statements, context, functionBody = false) {
   const { scope } = context;
   const names = /* @__PURE__ */ new Set();
   for (const statement of statements) {
     if (statement.type === "FunctionDeclaration") {
       const name = statement.id.name;
-      if (names.has(name)) {
+      if (names.has(name) && !(functionBody && scope.getOwnBindingKind(name) === "var")) {
         throw new Error(`Cannot redeclare binding '${name}' in the same scope.`);
       }
       const closure = createInterpretedClosure(statement, context, evaluateNode2);
@@ -145840,7 +145210,7 @@ function predeclareStatementListBindings(statements, context) {
         throw new Error(`Cannot redeclare binding '${name}' in the same scope.`);
       }
       names.add(name);
-      scope.declare(name, "const", closure);
+      scope.declare(name, functionBody ? "var" : "let", closure);
       continue;
     }
     if (statement.type !== "VariableDeclaration" || statement.kind === "var") {
@@ -154757,7 +154127,7 @@ var init_package2 = __esm({
   "package.json"() {
     package_default2 = {
       name: "poe-code",
-      version: "6.0.0",
+      version: "7.0.1",
       description: "CLI tool to configure Poe API for developer workflows.",
       license: "MIT",
       type: "module",