diff --git a/graal-js/src/com.oracle.js.parser/src/com/oracle/js/parser/Parser.java b/graal-js/src/com.oracle.js.parser/src/com/oracle/js/parser/Parser.java
index f925927e12c..e7f68b3c265 100644
--- a/graal-js/src/com.oracle.js.parser/src/com/oracle/js/parser/Parser.java
+++ b/graal-js/src/com.oracle.js.parser/src/com/oracle/js/parser/Parser.java
@@ -1046,7 +1046,7 @@ private Expression verifyAssignment(final long op, final Expression lhs, final E
                         throw invalidLHSError(lhs);
                     }
                     break;
-                } else if ((opType == ASSIGN || opType == ASSIGN_INIT) && isDestructuringLhs(lhs) && (inPatternPosition || !lhs.isParenthesized())) {
+                } else if ((opType == ASSIGN || opType == ASSIGN_INIT) && isDestructuringOrExtractorLhs(lhs) && (inPatternPosition || !lhs.isParenthesized())) {
                     verifyDestructuringAssignmentPattern(lhs, CONTEXT_ASSIGNMENT_TARGET);
                     break;
                 } else if (!(isWebCompatAssignmentTargetType(lhs) && (opType == ASSIGN || opType.isAssignmentOperator()))) {
@@ -1071,8 +1071,18 @@ private boolean isDestructuringLhs(Expression lhs) {
         return false;
     }
 
+    private boolean isDestructuringOrExtractorLhs(Expression lhs) {
+        if (isDestructuringLhs(lhs)) {
+            return true;
+        }
+        if (lhs instanceof CallNode) {
+            return env.extractors;
+        }
+        return false;
+    }
+
     private void verifyDestructuringAssignmentPattern(Expression pattern, String contextString) {
-        assert pattern instanceof ObjectNode || pattern instanceof ArrayLiteralNode;
+        assert pattern instanceof ObjectNode || pattern instanceof ArrayLiteralNode || pattern instanceof CallNode;
         pattern.accept(new VerifyDestructuringPatternNodeVisitor(new LexicalContext()) {
             @Override
             protected void verifySpreadElement(Expression lvalue) {
@@ -2479,10 +2489,14 @@ private ForVariableDeclarationListResult variableDeclarationList(TokenType varTy
             final int varLine = line;
             final long varToken = Token.recast(token, varType);
 
-            // Get name of var.
-            final Expression binding = bindingIdentifierOrPattern(yield, await, CONTEXT_VARIABLE_NAME);
-            final boolean isDestructuring = !(binding instanceof IdentNode);
-            if (isDestructuring) {
+            // Get left hand side.
+            final Expression binding = leftHandSideExpression(yield, await, CoverExpressionError.DENY);
+            if (binding.tokenType() == TokenType.NEW) {
+                throw error(AbstractParser.message(MSG_INVALID_LVALUE), binding.getToken());
+            }
+
+            final boolean isDestructuringOrExtracting = !(binding instanceof IdentNode);
+            if (isDestructuringOrExtracting) {
                 final int finalVarFlags = varFlags | VarNode.IS_DESTRUCTURING;
                 verifyDestructuringBindingPattern(binding, new Consumer<IdentNode>() {
                     @Override
@@ -2510,18 +2524,18 @@ public void accept(IdentNode identNode) {
                 next();
 
                 // Get initializer expression. Suppress IN if not statement.
-                if (!isDestructuring) {
+                if (!isDestructuringOrExtracting) {
                     pushDefaultName(binding);
                 }
                 try {
                     init = assignmentExpression(isStatement, yield, await);
                 } finally {
-                    if (!isDestructuring) {
+                    if (!isDestructuringOrExtracting) {
                         popDefaultName();
                     }
                 }
             } else if (isStatement) {
-                if (isDestructuring) {
+                if (isDestructuringOrExtracting) {
                     throw error(AbstractParser.message(MSG_MISSING_DESTRUCTURING_ASSIGNMENT), token);
                 } else if (varType == CONST) {
                     throw error(AbstractParser.message(MSG_MISSING_CONST_ASSIGNMENT, ((IdentNode) binding).getName()));
@@ -2529,7 +2543,7 @@ public void accept(IdentNode identNode) {
                 // else, if we are in a for loop, delay checking until we know the kind of loop
             }
 
-            if (!isDestructuring) {
+            if (!isDestructuringOrExtracting) {
                 assert init != null || varType != CONST || !isStatement;
                 final IdentNode ident = (IdentNode) binding;
                 if (varType != VAR && ident.getName().equals(LET.getName())) {
@@ -2716,6 +2730,13 @@ private Expression bindingPattern(boolean yield, boolean await) {
             return arrayLiteral(yield, await, CoverExpressionError.IGNORE);
         } else if (type == LBRACE) {
             return objectLiteral(yield, await, CoverExpressionError.IGNORE);
+        } else if (env.extractors && type == IDENT) {
+            final var extractor = leftHandSideExpression(yield, await, CoverExpressionError.DENY);
+            if (extractor instanceof CallNode) {
+                return extractor;
+            } else {
+                throw error(AbstractParser.message(MSG_EXPECTED_BINDING), extractor.getToken());
+            }
         } else {
             throw error(AbstractParser.message(MSG_EXPECTED_BINDING));
         }
@@ -2743,22 +2764,7 @@ public boolean enterLiteralNode(LiteralNode<?> literalNode) {
                 if (((ArrayLiteralNode) literalNode).hasSpread() && ((ArrayLiteralNode) literalNode).hasTrailingComma()) {
                     throw error("Rest element must be last", literalNode.getElementExpressions().get(literalNode.getElementExpressions().size() - 1).getToken());
                 }
-                boolean restElement = false;
-                for (Expression element : literalNode.getElementExpressions()) {
-                    if (element != null) {
-                        if (restElement) {
-                            throw error("Unexpected element after rest element", element.getToken());
-                        }
-                        if (element.isTokenType(SPREAD_ARRAY)) {
-                            restElement = true;
-                            Expression lvalue = ((UnaryNode) element).getExpression();
-                            verifySpreadElement(lvalue);
-                        } else {
-                            element.accept(this);
-                        }
-                    }
-                }
-                return false;
+                return handleNodeListWithSpread(literalNode.getElementExpressions(), SPREAD_ARRAY);
             } else {
                 return enterDefault(literalNode);
             }
@@ -2771,23 +2777,7 @@ public boolean enterObjectNode(ObjectNode objectNode) {
             if (objectNode.isParenthesized()) {
                 throw error(AbstractParser.message(MSG_INVALID_LVALUE), objectNode.getToken());
             }
-            boolean restElement = false;
-            for (PropertyNode property : objectNode.getElements()) {
-                if (property != null) {
-                    if (restElement) {
-                        throw error("Unexpected element after rest element", property.getToken());
-                    }
-                    Expression key = property.getKey();
-                    if (key.isTokenType(SPREAD_OBJECT)) {
-                        restElement = true;
-                        Expression lvalue = ((UnaryNode) key).getExpression();
-                        verifySpreadElement(lvalue);
-                    } else {
-                        property.accept(this);
-                    }
-                }
-            }
-            return false;
+            return this.handleNodeListWithSpread(objectNode.getElements(), SPREAD_OBJECT);
         }
 
         @Override
@@ -2810,6 +2800,39 @@ public boolean enterBinaryNode(BinaryNode binaryNode) {
                 return enterDefault(binaryNode);
             }
         }
+
+        @Override
+        public boolean enterCallNode(CallNode callNode) {
+            if (callNode.isParenthesized() || !env.extractors) {
+                throw error(AbstractParser.message(MSG_INVALID_LVALUE), callNode.getToken());
+            }
+            return handleNodeListWithSpread(callNode.getArgs(), SPREAD_ARGUMENT);
+        }
+
+        private boolean handleNodeListWithSpread(List<? extends Node> nodes, TokenType acceptableSpreadToken) {
+            boolean encounteredSpread = false;
+
+            for (final var node : nodes) {
+                if (node == null) {
+                    continue;
+                }
+                if (encounteredSpread) {
+                    throw error("Unexpected element after rest element", node.getToken());
+                }
+
+                final var key = node instanceof PropertyNode ? ((PropertyNode) node).getKey() : node;
+                if (key.isTokenType(acceptableSpreadToken)) {
+                    encounteredSpread = true;
+
+                    final var lvalue = ((UnaryNode) key).getExpression();
+                    verifySpreadElement(lvalue);
+                } else {
+                    node.accept(this);
+                }
+            }
+
+            return false;
+        }
     }
 
     /**
@@ -2817,7 +2840,7 @@ public boolean enterBinaryNode(BinaryNode binaryNode) {
      * declarations.
      */
     private void verifyDestructuringBindingPattern(Expression pattern, Consumer<IdentNode> identifierCallback) {
-        assert pattern instanceof ObjectNode || pattern instanceof ArrayLiteralNode;
+        assert pattern instanceof ObjectNode || pattern instanceof ArrayLiteralNode || pattern instanceof CallNode;
         pattern.accept(new VerifyDestructuringPatternNodeVisitor(new LexicalContext()) {
             @Override
             protected void verifySpreadElement(Expression lvalue) {
@@ -3076,8 +3099,8 @@ private void forStatement(boolean yield, boolean await) {
                                 throw error(AbstractParser.message(MSG_MANY_VARS_IN_FOR_IN_LOOP, isForOf || isForAwaitOf ? CONTEXT_OF : CONTEXT_IN), varDeclList.secondBinding.getToken());
                             }
                             init = varDeclList.firstBinding;
-                            assert init instanceof IdentNode || isDestructuringLhs(init) : init;
-                            if (varDeclList.declarationWithInitializerToken != 0 && (isStrictMode || type != IN || varType != VAR || isDestructuringLhs(init))) {
+                            assert init instanceof IdentNode || isDestructuringOrExtractorLhs(init) : init;
+                            if (varDeclList.declarationWithInitializerToken != 0 && (isStrictMode || type != IN || varType != VAR || isDestructuringOrExtractorLhs(init))) {
                                 /*
                                  * ES5 legacy: for (var i = AssignmentExpressionNoIn in Expression).
                                  * Invalid in ES6, but allowed in non-strict mode if no ES6 features
@@ -3154,7 +3177,7 @@ private boolean checkValidLValue(Expression init, String contextString) {
             return true;
         } else if (init instanceof AccessNode || init instanceof IndexNode) {
             return !((BaseNode) init).isOptional();
-        } else if (isDestructuringLhs(init)) {
+        } else if (isDestructuringOrExtractorLhs(init)) {
             verifyDestructuringAssignmentPattern(init, contextString);
             return true;
         } else {
@@ -3861,7 +3884,8 @@ private void tryStatement(boolean yield, boolean await) {
                         pattern = null;
                         ifExpression = null;
                     } else {
-                        if (isBindingIdentifier() || !(ES6_DESTRUCTURING && isES6())) {
+                        // If extractors are allowed, bindingPattern may start with an identifier so we need to look ahead
+                        if ((isBindingIdentifier() && (!env.extractors || Token.descType(getToken(k + 1)) == RPAREN)) || !(ES6_DESTRUCTURING && isES6())) {
                             pattern = null;
                             IdentNode catchParameter = bindingIdentifier(yield, await, CONTEXT_CATCH_PARAMETER);
                             exception = catchParameter.setIsCatchParameter();
@@ -5087,7 +5111,7 @@ private Expression memberExpression(boolean yield, boolean await, CoverExpressio
      * This helps report the first error location for cases like: <code>({x=i}[{y=j}])</code>.
      */
     private void verifyPrimaryExpression(Expression lhs, CoverExpressionError coverExpression) {
-        if (coverExpression != CoverExpressionError.DENY && coverExpression.hasError() && isDestructuringLhs(lhs)) {
+        if (coverExpression != CoverExpressionError.DENY && coverExpression.hasError() && isDestructuringOrExtractorLhs(lhs)) {
             /**
              * These token types indicate that the preceding PrimaryExpression is part of an
              * unfinished MemberExpression or other LeftHandSideExpression, which also means that it
@@ -5570,7 +5594,7 @@ private void formalParameter(final boolean yield, final boolean await) {
         final long paramToken = token;
         final int paramLine = line;
         IdentNode ident;
-        if (isBindingIdentifier() || !(ES6_DESTRUCTURING && isES6())) {
+        if (lookaheadIsSimpleFormalParameter() || !(ES6_DESTRUCTURING && isES6())) {
             ident = bindingIdentifier(yield, await, CONTEXT_FUNCTION_PARAMETER);
 
             if (type == ASSIGN && (ES6_DEFAULT_PARAMETER && isES6())) {
@@ -5609,6 +5633,18 @@ private void formalParameter(final boolean yield, final boolean await) {
         }
     }
 
+    /**
+     * check if this is a "simple" formal parameter; an ident followed by a comma, a closing parenthesis or an assign (default)
+     * i.e. not a binding pattern (in particular an extractor, which also starts with an ident)
+     */
+    private boolean lookaheadIsSimpleFormalParameter() {
+        if (!isBindingIdentifier()) {
+            return false;
+        }
+
+        return lookaheadFindTokenSkippingComments(COMMARIGHT) || lookaheadFindTokenSkippingComments(RPAREN) || lookaheadFindTokenSkippingComments(ASSIGN);
+    }
+
     private void functionRestParameter(final TokenType endType, final boolean yield, final boolean await) {
         final long paramToken = token;
         final int paramLine = line;
@@ -5683,7 +5719,7 @@ private static void addDefaultParameter(long paramToken, int paramFinish, int pa
     }
 
     private void addDestructuringParameter(long paramToken, int paramFinish, int paramLine, Expression target, Expression initializer, ParserContextFunctionNode function, boolean isRest) {
-        assert isDestructuringLhs(target);
+        assert isDestructuringOrExtractorLhs(target);
         // desugar to: target := (param === undefined) ? initializer : param;
         // we use an special positional parameter node not subjected to TDZ rules;
         // thereby, we forego the need for a synthetic param symbol to refer to the passed value.
@@ -6440,7 +6476,7 @@ private Expression assignmentExpression(boolean in, boolean yield, boolean await
         assert !(exprLhs instanceof ExpressionList);
 
         if (type.isAssignment()) {
-            if (canBeAssignmentPattern && !isDestructuringLhs(exprLhs)) {
+            if (canBeAssignmentPattern && !isDestructuringOrExtractorLhs(exprLhs)) {
                 // If LHS is not an AssignmentPattern, verify that it is a valid expression.
                 verifyExpression(coverExprLhs);
             }
@@ -6592,7 +6628,7 @@ private void convertArrowFunctionParameterList(Expression paramList, ParserConte
             return;
         }
         final int functionLine = function.getLineNumber();
-        if (paramListExpr instanceof IdentNode || paramListExpr.isTokenType(ASSIGN) || isDestructuringLhs(paramListExpr) || paramListExpr.isTokenType(SPREAD_ARGUMENT)) {
+        if (paramListExpr instanceof IdentNode || paramListExpr.isTokenType(ASSIGN) || isDestructuringOrExtractorLhs(paramListExpr) || paramListExpr.isTokenType(SPREAD_ARGUMENT)) {
             convertArrowParameter(paramListExpr, 0, functionLine, function);
         } else if (paramListExpr instanceof BinaryNode && Token.descType(paramListExpr.getToken()) == COMMARIGHT) {
             List<Expression> params = new ArrayList<>();
@@ -6645,7 +6681,7 @@ private void convertArrowParameter(Expression param, int index, int paramLine, P
 
                 addDefaultParameter(paramToken, param.getFinish(), paramLine, ident, initializer, currentFunction);
                 return;
-            } else if (isDestructuringLhs(lhs)) {
+            } else if (isDestructuringOrExtractorLhs(lhs)) {
                 // binding pattern with initializer
                 verifyDestructuringParameterBindingPattern(lhs, paramToken, paramLine);
 
@@ -6653,7 +6689,7 @@ private void convertArrowParameter(Expression param, int index, int paramLine, P
             } else {
                 throw error(AbstractParser.message(MSG_INVALID_ARROW_PARAMETER), paramToken);
             }
-        } else if (isDestructuringLhs(param)) {
+        } else if (isDestructuringOrExtractorLhs(param)) {
             // binding pattern
             long paramToken = param.getToken();
 
@@ -6669,7 +6705,7 @@ private void convertArrowParameter(Expression param, int index, int paramLine, P
             if (restParam instanceof IdentNode) {
                 IdentNode ident = ((IdentNode) restParam).setIsRestParameter();
                 convertArrowParameter(ident, index, paramLine, currentFunction);
-            } else if (isDestructuringLhs(restParam)) {
+            } else if (isDestructuringOrExtractorLhs(restParam)) {
                 verifyDestructuringParameterBindingPattern(restParam, restParam.getToken(), paramLine);
                 addDestructuringParameter(restParam.getToken(), restParam.getFinish(), paramLine, restParam, null, currentFunction, true);
             } else {
@@ -6731,19 +6767,18 @@ private boolean lookbehindNoLineTerminatorAfterAsync() {
     }
 
     private boolean lookaheadIsArrow() {
-        // find ARROW, skipping over COMMENT
-        int i = 1;
-        for (;;) {
-            TokenType t = T(k + i++);
-            if (t == ARROW) {
-                break;
-            } else if (t == COMMENT) {
-                continue;
-            } else {
+        return lookaheadFindTokenSkippingComments(ARROW);
+    }
+
+    private boolean lookaheadFindTokenSkippingComments(TokenType target) {
+        for (int i = 1;; i++) {
+            TokenType t = T(k + i);
+            if (t == target) {
+                return true;
+            } else if (t != COMMENT) {
                 return false;
             }
         }
-        return true;
     }
 
     /**
diff --git a/graal-js/src/com.oracle.js.parser/src/com/oracle/js/parser/ScriptEnvironment.java b/graal-js/src/com.oracle.js.parser/src/com/oracle/js/parser/ScriptEnvironment.java
index 9605e821209..c95bb2e49f7 100644
--- a/graal-js/src/com.oracle.js.parser/src/com/oracle/js/parser/ScriptEnvironment.java
+++ b/graal-js/src/com.oracle.js.parser/src/com/oracle/js/parser/ScriptEnvironment.java
@@ -133,6 +133,9 @@ public enum FunctionStatementBehavior {
     /** Are source phase imports enabled. */
     final boolean sourcePhaseImports;
 
+    /** Are extractors enabled. */
+    final boolean extractors;
+
     public ScriptEnvironment(boolean strict,
                     int ecmaScriptVersion,
                     boolean emptyStatements,
@@ -149,6 +152,7 @@ public ScriptEnvironment(boolean strict,
                     boolean privateFieldsIn,
                     boolean topLevelAwait,
                     boolean v8Intrinsics,
+                    boolean extractors,
                     FunctionStatementBehavior functionStatementBehavior) {
         this.constAsVar = constAsVar;
         this.emptyStatements = emptyStatements;
@@ -167,6 +171,7 @@ public ScriptEnvironment(boolean strict,
         this.privateFieldsIn = privateFieldsIn;
         this.topLevelAwait = topLevelAwait;
         this.v8Intrinsics = v8Intrinsics;
+        this.extractors = extractors;
     }
 
     public boolean isStrict() {
@@ -195,6 +200,7 @@ public static final class Builder {
         private boolean privateFieldsIn = false;
         private boolean topLevelAwait = false;
         private boolean v8Intrinsics = false;
+        private boolean extractors = false;
         private FunctionStatementBehavior functionStatementBehavior = FunctionStatementBehavior.ERROR;
 
         private Builder() {
@@ -284,9 +290,14 @@ public Builder functionStatementBehavior(FunctionStatementBehavior functionState
             return this;
         }
 
+        public Builder extractors(boolean extractors) {
+            this.extractors = extractors;
+            return this;
+        }
+
         public ScriptEnvironment build() {
             return new ScriptEnvironment(strict, ecmaScriptVersion, emptyStatements, syntaxExtensions, scripting, shebang, constAsVar, allowBigInt, annexB,
-                            classFields, importAttributes, importAssertions, sourcePhaseImports, privateFieldsIn, topLevelAwait, v8Intrinsics, functionStatementBehavior);
+                            classFields, importAttributes, importAssertions, sourcePhaseImports, privateFieldsIn, topLevelAwait, v8Intrinsics, extractors, functionStatementBehavior);
         }
     }
 }
diff --git a/graal-js/src/com.oracle.js.parser/src/com/oracle/js/parser/ir/Node.java b/graal-js/src/com.oracle.js.parser/src/com/oracle/js/parser/ir/Node.java
index 18c63c0ecb0..b6c2bf44850 100644
--- a/graal-js/src/com.oracle.js.parser/src/com/oracle/js/parser/ir/Node.java
+++ b/graal-js/src/com.oracle.js.parser/src/com/oracle/js/parser/ir/Node.java
@@ -254,7 +254,7 @@ public long getToken() {
         return token;
     }
 
-    // on change, we have to replace the entire list, that's we can't simple do ListIterator.set
+    // on change, we have to replace the entire list, that's we can't simply do ListIterator.set
     static <T extends Node> List<T> accept(final NodeVisitor<? extends LexicalContext> visitor, final List<T> list) {
         final int size = list.size();
         if (size == 0) {
diff --git a/graal-js/src/com.oracle.truffle.js.parser/src/com/oracle/truffle/js/parser/GraalJSParserHelper.java b/graal-js/src/com.oracle.truffle.js.parser/src/com/oracle/truffle/js/parser/GraalJSParserHelper.java
index 7699dc779bd..1298a5c820c 100644
--- a/graal-js/src/com.oracle.truffle.js.parser/src/com/oracle/truffle/js/parser/GraalJSParserHelper.java
+++ b/graal-js/src/com.oracle.truffle.js.parser/src/com/oracle/truffle/js/parser/GraalJSParserHelper.java
@@ -201,6 +201,7 @@ private static ScriptEnvironment makeScriptEnvironment(JSParserOptions parserOpt
         builder.privateFieldsIn(parserOptions.privateFieldsIn());
         builder.topLevelAwait(parserOptions.topLevelAwait());
         builder.v8Intrinsics(parserOptions.v8Intrinsics());
+        builder.extractors(parserOptions.extractors());
         if (parserOptions.functionStatementError()) {
             builder.functionStatementBehavior(FunctionStatementBehavior.ERROR);
         } else {
diff --git a/graal-js/src/com.oracle.truffle.js.parser/src/com/oracle/truffle/js/parser/GraalJSTranslator.java b/graal-js/src/com.oracle.truffle.js.parser/src/com/oracle/truffle/js/parser/GraalJSTranslator.java
index 61a1d660c27..b54e26e7db6 100644
--- a/graal-js/src/com.oracle.truffle.js.parser/src/com/oracle/truffle/js/parser/GraalJSTranslator.java
+++ b/graal-js/src/com.oracle.truffle.js.parser/src/com/oracle/truffle/js/parser/GraalJSTranslator.java
@@ -119,7 +119,9 @@
 import com.oracle.truffle.js.nodes.access.DeclareEvalVariableNode;
 import com.oracle.truffle.js.nodes.access.DeclareGlobalNode;
 import com.oracle.truffle.js.nodes.access.GetIteratorUnaryNode;
+import com.oracle.truffle.js.nodes.access.GetMethodNode;
 import com.oracle.truffle.js.nodes.access.GlobalPropertyNode;
+import com.oracle.truffle.js.nodes.access.IteratorToArrayNode;
 import com.oracle.truffle.js.nodes.access.JSConstantNode;
 import com.oracle.truffle.js.nodes.access.JSReadFrameSlotNode;
 import com.oracle.truffle.js.nodes.access.JSWriteFrameSlotNode;
@@ -151,6 +153,7 @@
 import com.oracle.truffle.js.nodes.control.SequenceNode;
 import com.oracle.truffle.js.nodes.control.StatementNode;
 import com.oracle.truffle.js.nodes.control.SuspendNode;
+import com.oracle.truffle.js.nodes.extractor.InvokeCustomMatcherOrThrowNode;
 import com.oracle.truffle.js.nodes.function.AbstractFunctionArgumentsNode;
 import com.oracle.truffle.js.nodes.function.BlockScopeNode;
 import com.oracle.truffle.js.nodes.function.EvalNode;
@@ -2858,8 +2861,7 @@ private JavaScriptNode transformAssignmentImpl(Expression assignmentExpression,
                 // fall through
             case IDENT:
                 if (lhsExpression instanceof CallNode callNode) {
-                    assert callNode.isWebCompatAssignmentTargetType();
-                    assignedNode = factory.createDual(context, transform(lhsExpression), factory.createThrowError(JSErrorType.ReferenceError, INVALID_LHS));
+                    assignedNode = transformAssignmentExtractor(callNode, assignedValue, initializationAssignment);
                 } else {
                     assignedNode = transformAssignmentIdent((IdentNode) lhsExpression, assignedValue, binaryOp, returnOldValue, convertLHSToNumeric, initializationAssignment);
                 }
@@ -2907,40 +2909,38 @@ private JavaScriptNode transformAssignmentIdent(IdentNode identNode, JavaScriptN
                 rhs = checkMutableBinding(rhs, scopeVar.getName());
             }
             return scopeVar.createWriteNode(rhs);
+        } else if (isLogicalOp(binaryOp)) {
+            assert !convertLHSToNumeric && !returnOldValue && assignedValue != null;
+            if (constAssignment) {
+                rhs = checkMutableBinding(rhs, scopeVar.getName());
+            }
+            JavaScriptNode readNode = tagExpression(scopeVar.createReadNode(), identNode);
+            JavaScriptNode writeNode = scopeVar.createWriteNode(rhs);
+            return factory.createBinary(context, binaryOp, readNode, writeNode);
         } else {
-            if (isLogicalOp(binaryOp)) {
-                assert !convertLHSToNumeric && !returnOldValue && assignedValue != null;
-                if (constAssignment) {
-                    rhs = checkMutableBinding(rhs, scopeVar.getName());
-                }
-                JavaScriptNode readNode = tagExpression(scopeVar.createReadNode(), identNode);
-                JavaScriptNode writeNode = scopeVar.createWriteNode(rhs);
-                return factory.createBinary(context, binaryOp, readNode, writeNode);
+            // e.g.: lhs *= rhs => lhs = lhs * rhs
+            // If lhs is a side-effecting getter that deletes lhs, we must not throw a
+            // ReferenceError at the lhs assignment since the lhs reference is already resolved.
+            // We also need to ensure that HasBinding is idempotent or evaluated at most once.
+            Pair<Supplier<JavaScriptNode>, UnaryOperator<JavaScriptNode>> pair = scopeVar.createCompoundAssignNode();
+            JavaScriptNode readNode = tagExpression(pair.getFirst().get(), identNode);
+            if (convertLHSToNumeric) {
+                readNode = factory.createToNumericOperand(readNode);
+            }
+            VarRef prevValueTemp = null;
+            if (returnOldValue) {
+                prevValueTemp = environment.createTempVar();
+                readNode = prevValueTemp.createWriteNode(readNode);
+            }
+            JavaScriptNode binOpNode = tagExpression(factory.createBinary(context, binaryOp, readNode, rhs), identNode);
+            if (constAssignment) {
+                binOpNode = checkMutableBinding(binOpNode, scopeVar.getName());
+            }
+            JavaScriptNode writeNode = pair.getSecond().apply(binOpNode);
+            if (returnOldValue) {
+                return factory.createDual(context, writeNode, prevValueTemp.createReadNode());
             } else {
-                // e.g.: lhs *= rhs => lhs = lhs * rhs
-                // If lhs is a side-effecting getter that deletes lhs, we must not throw a
-                // ReferenceError at the lhs assignment since the lhs reference is already resolved.
-                // We also need to ensure that HasBinding is idempotent or evaluated at most once.
-                Pair<Supplier<JavaScriptNode>, UnaryOperator<JavaScriptNode>> pair = scopeVar.createCompoundAssignNode();
-                JavaScriptNode readNode = tagExpression(pair.getFirst().get(), identNode);
-                if (convertLHSToNumeric) {
-                    readNode = factory.createToNumericOperand(readNode);
-                }
-                VarRef prevValueTemp = null;
-                if (returnOldValue) {
-                    prevValueTemp = environment.createTempVar();
-                    readNode = prevValueTemp.createWriteNode(readNode);
-                }
-                JavaScriptNode binOpNode = tagExpression(factory.createBinary(context, binaryOp, readNode, rhs), identNode);
-                if (constAssignment) {
-                    binOpNode = checkMutableBinding(binOpNode, scopeVar.getName());
-                }
-                JavaScriptNode writeNode = pair.getSecond().apply(binOpNode);
-                if (returnOldValue) {
-                    return factory.createDual(context, writeNode, prevValueTemp.createReadNode());
-                } else {
-                    return writeNode;
-                }
+                return writeNode;
             }
         }
     }
@@ -3070,14 +3070,19 @@ private JavaScriptNode transformIndexAssignment(IndexNode indexNode, JavaScriptN
     }
 
     private JavaScriptNode transformDestructuringArrayAssignment(Expression lhsExpression, JavaScriptNode assignedValue, boolean initializationAssignment) {
+        VarRef valueTempVar = environment.createTempVar();
+        JavaScriptNode initValue = valueTempVar.createWriteNode(assignedValue);
+        JavaScriptNode getIterator = factory.createGetIterator(initValue);
         LiteralNode.ArrayLiteralNode arrayLiteralNode = (LiteralNode.ArrayLiteralNode) lhsExpression;
         List<Expression> elementExpressions = arrayLiteralNode.getElementExpressions();
+
+        return this.transformDestructuringArrayAssignment(elementExpressions, getIterator, valueTempVar, initializationAssignment);
+    }
+
+    private JavaScriptNode transformDestructuringArrayAssignment(List<Expression> elementExpressions, JavaScriptNode getIterator, VarRef valueTempVar, boolean initializationAssignment) {
         JavaScriptNode[] initElements = javaScriptNodeArray(elementExpressions.size());
         VarRef iteratorTempVar = environment.createTempVar();
-        VarRef valueTempVar = environment.createTempVar();
-        JavaScriptNode initValue = valueTempVar.createWriteNode(assignedValue);
         // By default, we use the hint to track the type of iterator.
-        JavaScriptNode getIterator = factory.createGetIterator(initValue);
         JavaScriptNode initIteratorTempVar = iteratorTempVar.createWriteNode(getIterator);
 
         for (int i = 0; i < elementExpressions.size(); i++) {
@@ -3099,7 +3104,7 @@ private JavaScriptNode transformDestructuringArrayAssignment(Expression lhsExpre
             if (init != null) {
                 rhsNode = factory.createNotUndefinedOr(rhsNode, transform(init));
             }
-            if (lhsExpr != null && lhsExpr.isTokenType(TokenType.SPREAD_ARRAY)) {
+            if (lhsExpr != null && (lhsExpr.isTokenType(TokenType.SPREAD_ARRAY) || lhsExpr.isTokenType(TokenType.SPREAD_ARGUMENT))) {
                 rhsNode = factory.createIteratorToArray(context, iteratorTempVar.createReadNode());
                 lhsExpr = ((UnaryNode) lhsExpr).getExpression();
             }
@@ -3117,6 +3122,32 @@ private JavaScriptNode transformDestructuringArrayAssignment(Expression lhsExpre
                         factory.createExprBlock(resetIterator, resetValue));
     }
 
+    private JavaScriptNode transformAssignmentExtractor(CallNode fakeCallNode, JavaScriptNode assignedValue, boolean initializationAssignment) {
+        final var functionExpr = fakeCallNode.getFunction();
+        final var function = transform(functionExpr);
+
+        var receiver = function;
+        if (functionExpr instanceof AccessNode) {
+            final AccessNode accessNode = (AccessNode) functionExpr;
+            receiver = transform(accessNode.getBase());
+        }
+
+        // It's important to only read from assignedValue once, otherwise we might advance an iterator multiple times
+        VarRef assignedValueTempVar = environment.createTempVar();
+        JavaScriptNode storeAssignedValue = assignedValueTempVar.createWriteNode(assignedValue);
+        JavaScriptNode readAssignedValue = assignedValueTempVar.createReadNode();
+
+        final var invokeCustomMatcherOrThrowNode = factory.createInvokeCustomMatcherOrThrow(context, function, readAssignedValue, receiver, environment.isStrictMode());
+
+        final var args = fakeCallNode.getArgs();
+        VarRef valueTempVar = environment.createTempVar();
+        return createBlock(
+                storeAssignedValue,
+                this.transformDestructuringArrayAssignment(args, invokeCustomMatcherOrThrowNode, valueTempVar, initializationAssignment),
+                valueTempVar.createWriteNode(assignedValueTempVar.createReadNode())
+        );
+    }
+
     private JavaScriptNode transformDestructuringObjectAssignment(Expression lhsExpression, JavaScriptNode assignedValue, boolean initializationAssignment) {
         ObjectNode objectLiteralNode = (ObjectNode) lhsExpression;
         List<PropertyNode> propertyExpressions = objectLiteralNode.getElements();
diff --git a/graal-js/src/com.oracle.truffle.js.test/js/assert.js b/graal-js/src/com.oracle.truffle.js.test/js/assert.js
index 51b49599f2b..f04dae86548 100644
--- a/graal-js/src/com.oracle.truffle.js.test/js/assert.js
+++ b/graal-js/src/com.oracle.truffle.js.test/js/assert.js
@@ -24,11 +24,12 @@ function assertThrows(fn, errorType, msg) {
     throw Error('error expected for method: ' + fn);
 }
 
-function assertEqual(expected, actual) {
+function assertEqual(expected, actual, message) {
     if (expected != actual) {
         var error = 'Objects not equal - '
                 + 'expected: [' + expected + '] vs. '
-                + 'actual: [' + actual +']';
+                + 'actual: [' + actual +']'
+                + (message ? ' : ' +  message : '');
         throw new Error(error);
     }
 }
@@ -43,11 +44,12 @@ function _isSame(a, b) {
     return (a !== a) && (b !== b);
 }
 
-function assertSame(expected, actual) {
+function assertSame(expected, actual, message) {
     if (!_isSame(expected, actual)) {
         var error = 'Objects not same - '
                 + 'expected: [' + expected + '] vs. '
-                + 'actual: [' + actual +']';
+                + 'actual: [' + actual +']'
+                + (message ? ' : ' +  message : '');
         throw new Error(error);
     }
 }
@@ -60,12 +62,12 @@ function assertSameContent(expected, actual) {
     }
 }
 
-function assertTrue(condition) {
-    assertSame(true, condition);
+function assertTrue(condition, message) {
+    assertSame(true, condition, message);
 }
 
-function assertFalse(condition) {
-    assertSame(false, condition);
+function assertFalse(condition, message) {
+    assertSame(false, condition, message);
 }
 
 function fail(msg) {
diff --git a/graal-js/src/com.oracle.truffle.js.test/js/extractors/binding-and-assignment.js b/graal-js/src/com.oracle.truffle.js.test/js/extractors/binding-and-assignment.js
new file mode 100644
index 00000000000..b5cbd82f0e9
--- /dev/null
+++ b/graal-js/src/com.oracle.truffle.js.test/js/extractors/binding-and-assignment.js
@@ -0,0 +1,371 @@
+/**
+ * @option js.extractors
+ */
+
+/**
+ * Argument Binding and Assignment
+ *
+ * Tests that:
+ * - In binding contexts (variable declarations), arguments create new bindings
+ * - In assignment contexts, arguments must be valid LHS targets
+ * - Assignment targets can include property access, array indexing, etc.
+ */
+
+load('../assert.js');
+load('common.js');
+
+// Binding Context - const Creates New Bindings
+{
+    const p = new Pair(1, 2);
+    const Pair(x, y) = p;
+
+    // x and y are new bindings created by the declaration
+    assertSame(1, x);
+    assertSame(2, y);
+
+    // They are independent variables
+    const x2 = x + 10;
+    const y2 = y + 20;
+    assertSame(11, x2);
+    assertSame(22, y2);
+}
+
+// Binding Context - let Creates New Bindings
+{
+    const p = new Pair(3, 4);
+    let Pair(x, y) = p;
+
+    assertSame(3, x);
+    assertSame(4, y);
+
+    // Variables can be reassigned (mutable bindings)
+    x = x * 2;
+    y = y * 2;
+    assertSame(6, x);
+    assertSame(8, y);
+}
+
+// Binding Context - var Creates New Bindings
+{
+    const p = new Pair(5, 6);
+    var Pair(varX, varY) = p;
+
+    assertSame(5, varX);
+    assertSame(6, varY);
+}
+
+// Binding Context - Function Parameters Create New Bindings
+{
+    function test(Pair(x, y)) {
+        // x and y are parameter bindings
+        assertSame(7, x);
+        assertSame(8, y);
+
+        // Can be modified within the function
+        x = x + 1;
+        y = y + 1;
+        return { x, y };
+    }
+
+    const result = test(new Pair(7, 8));
+    assertSame(8, result.x);
+    assertSame(9, result.y);
+}
+
+// Assignment Context - Simple Variables
+{
+    const p = new Pair(9, 10);
+    let x, y;
+
+    // Assignment to existing variables
+    Pair(x, y) = p;
+
+    assertSame(9, x);
+    assertSame(10, y);
+}
+
+// Assignment Context - Object Properties
+{
+    const p = new Pair(11, 12);
+    const obj = {};
+
+    // Assignment to object properties
+    Pair(obj.x, obj.y) = p;
+
+    assertSame(11, obj.x);
+    assertSame(12, obj.y);
+}
+
+// Assignment Context - Nested Object Properties
+{
+    const p = new Pair(13, 14);
+    const obj = { nested: {} };
+
+    Pair(obj.nested.x, obj.nested.y) = p;
+
+    assertSame(13, obj.nested.x);
+    assertSame(14, obj.nested.y);
+}
+
+// Assignment Context - Array Elements
+{
+    const p = new Pair(15, 16);
+    const arr = [];
+
+    // Assignment to array indices
+    Pair(arr[0], arr[1]) = p;
+
+    assertSame(15, arr[0]);
+    assertSame(16, arr[1]);
+}
+
+// Assignment Context - Mixed Array Indices
+{
+    const p = new Pair(17, 18);
+    const arr = new Array(10);
+
+    Pair(arr[5], arr[9]) = p;
+
+    assertSame(17, arr[5]);
+    assertSame(18, arr[9]);
+}
+
+// Assignment Context - Computed Property Access
+{
+    const t = new Triple(19, 20, 21);
+    const obj = {};
+    const keys = ['a', 'b', 'c'];
+
+    Triple(obj[keys[0]], obj[keys[1]], obj[keys[2]]) = t;
+
+    assertSame(19, obj.a);
+    assertSame(20, obj.b);
+    assertSame(21, obj.c);
+}
+
+// Assignment Context - Mixed Targets
+{
+    const t = new Triple(22, 23, "24");
+    let x;
+    const obj = {};
+    const arr = [];
+
+    // Mix of variable, object property, and array element
+    Triple(x, obj.prop, arr[0]) = t;
+
+    assertSame(22, x);
+    assertSame(23, obj.prop);
+    assertSame("24", arr[0]);
+}
+
+// Assignment Context - Nested Structures
+{
+    const t = new Triple(24, 25, 26);
+    const state = { data: {}, list: [] };
+
+    Triple(state.data.a, state.data.b, state.list[0]) = t;
+
+    assertSame(24, state.data.a);
+    assertSame(25, state.data.b);
+    assertSame(26, state.list[0]);
+}
+
+// Assignment Context - this Properties in Method
+{
+    class Storage {
+        store(p) {
+            Pair(this.x, this.y) = p;
+        }
+
+        get() {
+            return { x: this.x, y: this.y };
+        }
+    }
+
+    const storage = new Storage();
+    storage.store(new Pair(27, 28));
+
+    const result = storage.get();
+    assertSame(27, result.x);
+    assertSame(28, result.y);
+}
+
+// Assignment Context - Global Object Properties
+{
+    const p = new Pair(29, 30);
+
+    Pair(globalThis.testX, globalThis.testY) = p;
+
+    assertSame(29, globalThis.testX);
+    assertSame(30, globalThis.testY);
+
+    // Cleanup
+    delete globalThis.testX;
+    delete globalThis.testY;
+}
+
+// Assignment Context - Complex LHS Expressions
+{
+    const p = new Pair(31, 32);
+    const obj = { items: [{}, {}, {}] };
+
+    Pair(obj.items[1].x, obj.items[2].y) = p;
+
+    assertSame(31, obj.items[1].x);
+    assertSame(32, obj.items[2].y);
+}
+
+// Binding and Assignment - Default Values in Binding
+{
+    class Optional {
+        constructor(value) {
+            this.value = value;
+        }
+
+        static [Symbol.customMatcher](obj) {
+            return [obj.value];
+        }
+    }
+
+    // Default value is used when undefined
+    const Optional(x = 100) = new Optional(undefined);
+    assertSame(100, x);
+
+    // Default value is not used when value is present
+    const Optional(y = 100) = new Optional(50);
+    assertSame(50, y);
+}
+
+// Assignment - Default Values in Assignment
+{
+    class Optional {
+        constructor(value) {
+            this.value = value;
+        }
+
+        static [Symbol.customMatcher](obj) {
+            return [obj.value];
+        }
+    }
+
+    let a, b;
+
+    // Default value in assignment context
+    Optional(a = 200) = new Optional(undefined);
+    assertSame(200, a);
+
+    Optional(b = 200) = new Optional(75);
+    assertSame(75, b);
+}
+
+// Binding Context - Rest Pattern
+{
+    const t = new Triple(33, 34, 35);
+    const Triple(first, ...rest) = t;
+
+    assertSame(33, first);
+    assertSameContent([34, 35], rest);
+}
+
+// Assignment Context - Rest Pattern
+{
+    const t = new Triple(36, 37, 38);
+    let a, b;
+
+    Triple(a, ...b) = t;
+
+    assertSame(36, a);
+    assertSameContent([37, 38], b);
+}
+
+// Assignment Context - Nested Extractors with Property Access
+{
+    class Container {
+        constructor(value) {
+            this.value = value;
+        }
+
+        static [Symbol.customMatcher](obj) {
+            return [obj.value];
+        }
+    }
+
+    const obj = {};
+    const nested = new Container(new Pair(39, 40));
+
+    Container(Pair(obj.x, obj.y)) = nested;
+
+    assertSame(39, obj.x);
+    assertSame(40, obj.y);
+}
+
+// Binding and Assignment - Scoping
+{
+    const p = new Pair(41, 42);
+
+    // Binding creates new scope-local variables
+    {
+        const Pair(x, y) = p;
+        assertSame(41, x);
+        assertSame(42, y);
+    }
+
+    // x and y are not accessible here (would throw ReferenceError)
+    assertThrows(() => x, ReferenceError);
+    assertThrows(() => y, ReferenceError);
+}
+
+// Assignment - Preserves Existing Variables
+{
+    const p1 = new Pair(43, 44);
+    const p2 = new Pair(45, 46);
+
+    let x, y;
+
+    Pair(x, y) = p1;
+    assertSame(43, x);
+    assertSame(44, y);
+
+    // Assignment updates the same variables
+    Pair(x, y) = p2;
+    assertSame(45, x);
+    assertSame(46, y);
+}
+
+// Assignment Context - Symbol Properties
+{
+    const p = new Pair(47, 48);
+    const obj = {};
+    const symX = Symbol('x');
+    const symY = Symbol('y');
+
+    Pair(obj[symX], obj[symY]) = p;
+
+    assertSame(47, obj[symX]);
+    assertSame(48, obj[symY]);
+}
+
+// Assignment Context - Dynamic Property Names
+{
+    const p = new Pair(49, 50);
+    const obj = {};
+
+    function getProp(name) {
+        return 'prop_' + name;
+    }
+
+    Pair(obj[getProp('x')], obj[getProp('y')]) = p;
+
+    assertSame(49, obj.prop_x);
+    assertSame(50, obj.prop_y);
+}
+
+// Binding Context - Nested Destructuring with Extractors
+{
+    const p = new Pair(51, 52);
+    const { wrapper: Pair(x, y) } = { wrapper: p };
+
+    assertSame(51, x);
+    assertSame(52, y);
+}
+
diff --git a/graal-js/src/com.oracle.truffle.js.test/js/extractors/common.js b/graal-js/src/com.oracle.truffle.js.test/js/extractors/common.js
new file mode 100644
index 00000000000..e1b5e1f5517
--- /dev/null
+++ b/graal-js/src/com.oracle.truffle.js.test/js/extractors/common.js
@@ -0,0 +1,32 @@
+/**
+ * Common test classes and utilities for extractor tests.
+ */
+
+class Pair {
+    constructor(first, second) {
+        this.first = first;
+        this.second = second;
+    }
+
+    static [Symbol.customMatcher](pair) {
+        return [pair.first, pair.second];
+    }
+}
+
+class Triple {
+    constructor(a, b, c) {
+        this.a = a;
+        this.b = b;
+        this.c = c;
+    }
+
+    static [Symbol.customMatcher](triple) {
+        return [triple.a, triple.b, triple.c];
+    }
+}
+
+const PlainObjectWithCustomMatcher = {
+    [Symbol.customMatcher](obj) {
+        return Object.entries(obj).sort();
+    }
+}
diff --git a/graal-js/src/com.oracle.truffle.js.test/js/extractors/error-handling.js b/graal-js/src/com.oracle.truffle.js.test/js/extractors/error-handling.js
new file mode 100644
index 00000000000..ce47d853adb
--- /dev/null
+++ b/graal-js/src/com.oracle.truffle.js.test/js/extractors/error-handling.js
@@ -0,0 +1,86 @@
+/**
+ * @option js.extractors
+ */
+
+/**
+ * Error Handling
+ *
+ * Tests error scenarios and side effects in extractor patterns:
+ * - Call expression assignment errors with side effects
+ * - Error propagation from custom matchers
+ */
+
+load('../assert.js');
+
+// Call Assignment Error with Side Effect
+// https://github.com/tc39/proposal-extractors/issues/34
+{
+    let sideEffectHappened = false;
+
+    function f() {
+        sideEffectHappened = true;
+    }
+
+    try {
+        f() = 1;
+    } catch (error) {
+        if (!sideEffectHappened) {
+            console.log(error);
+        }
+        assertTrue(sideEffectHappened, 'Side effect should happen before ReferenceError');
+        assertTrue(error instanceof ReferenceError, 'Should throw ReferenceError');
+    }
+}
+
+// CustomMatcher Error - Returns Non-Object
+{
+    class ReturnsNull {
+        static [Symbol.customMatcher]() {
+            return null;
+        }
+    }
+
+    try {
+        const ReturnsNull(x) = new ReturnsNull();
+        fail('Should have thrown TypeError');
+    } catch (e) {
+        assertTrue(e instanceof TypeError, 'Should throw TypeError for null return');
+    }
+}
+
+// CustomMatcher Error - Throws During Execution
+{
+    class ThrowsError {
+        static [Symbol.customMatcher]() {
+            throw new Error("Custom matcher error");
+        }
+    }
+
+    try {
+        const ThrowsError(x) = new ThrowsError();
+        fail('Should have propagated the error');
+    } catch (e) {
+        assertSame("Custom matcher error", e.message);
+    }
+}
+
+// CustomMatcher Error - Iterator Error
+{
+    class BadIterator {
+        static [Symbol.customMatcher]() {
+            return {
+                [Symbol.iterator]() {
+                    throw new Error("Iterator creation failed");
+                }
+            };
+        }
+    }
+
+    try {
+        const BadIterator(x) = new BadIterator();
+        fail('Should have thrown error from iterator');
+    } catch (e) {
+        assertSame("Iterator creation failed", e.message);
+    }
+}
+
diff --git a/graal-js/src/com.oracle.truffle.js.test/js/extractors/examples/date-extractor.js b/graal-js/src/com.oracle.truffle.js.test/js/extractors/examples/date-extractor.js
new file mode 100644
index 00000000000..01a16cb90b6
--- /dev/null
+++ b/graal-js/src/com.oracle.truffle.js.test/js/extractors/examples/date-extractor.js
@@ -0,0 +1,66 @@
+/**
+ * @option js.extractors
+ */
+
+load('../../assert.js');
+
+const DateExtractor = {
+    [Symbol.customMatcher](value) {
+        if (value instanceof Date) {
+            return [value];
+        } else if (typeof value === "number") {
+            return [new Date(value)];
+        } else if (typeof value === "string") {
+            return [new Date(Date.parse(value))];
+        }
+    }
+};
+
+class Book {
+    constructor({
+        isbn,
+        title,
+        // Extract `createdAt` as a Date
+        createdAt: DateExtractor(createdAt) = new Date(),
+        modifiedAt: DateExtractor(modifiedAt) = createdAt
+    }) {
+        this.isbn = isbn;
+        this.title = title;
+        this.createdAt = createdAt;
+        this.modifiedAt = modifiedAt;
+    }
+}
+
+{
+    const date = new Date("1970-01-01T00:00:00Z");
+    const book = new Book({ isbn: "...", title: "...", createdAt: date });
+    assertSame(date.valueOf(), book.createdAt.valueOf());
+}
+
+{
+    const msSinceEpoch = 1000;
+    const book = new Book({ isbn: "...", title: "...", createdAt: msSinceEpoch });
+    assertSame(msSinceEpoch, book.createdAt.valueOf());
+}
+
+{
+    const createdAt = "1970-01-01T00Z";
+    const book = new Book({ isbn: "...", title: "...", createdAt });
+    assertSame(Date.parse(createdAt), book.createdAt.valueOf());
+}
+
+{
+    const createdAt = new Date("2025-01-01");
+    const book = new Book({ isbn: "123", title: "Test Book", createdAt });
+    assertSame(book.createdAt.valueOf(), book.modifiedAt.valueOf());
+}
+
+{
+    const beforeCreation = Date.now();
+    const book = new Book({ isbn: "456", title: "Another Book" });
+    const afterCreation = Date.now();
+
+    assertTrue(book.createdAt.valueOf() >= beforeCreation);
+    assertTrue(book.createdAt.valueOf() <= afterCreation);
+}
+
diff --git a/graal-js/src/com.oracle.truffle.js.test/js/extractors/examples/map-extractor.js b/graal-js/src/com.oracle.truffle.js.test/js/extractors/examples/map-extractor.js
new file mode 100644
index 00000000000..3340f7aabf7
--- /dev/null
+++ b/graal-js/src/com.oracle.truffle.js.test/js/extractors/examples/map-extractor.js
@@ -0,0 +1,116 @@
+/**
+ * @option js.extractors
+ */
+
+load('../../assert.js');
+
+const MapExtractor = {
+    [Symbol.customMatcher](map) {
+        const obj = {};
+        for (const [key, value] of map) {
+            obj[typeof key === "symbol" ? key : `${key}`] = value;
+        }
+        return [obj];
+    }
+};
+
+// Basic Map extraction
+{
+    const obj = {
+        map: new Map([["a", 1], ["b", 2]])
+    };
+
+    const { map: MapExtractor({ a, b }) } = obj;
+
+    assertSame(a, 1);
+    assertSame(b, 2);
+}
+
+// Map with various key types
+{
+    const sym = Symbol('key');
+    const map = new Map([
+        ["string", 10],
+        [42, 20],
+        [sym, 30]
+    ]);
+
+    const MapExtractor({ string, "42": numKey, [sym]: symValue }) = map;
+
+    assertSame(10, string);
+    assertSame(20, numKey);
+    assertSame(30, symValue);
+}
+
+// Nested object with Map
+{
+    const data = {
+        metadata: {
+            values: new Map([
+                ["x", 100],
+                ["y", 200],
+                ["z", 300]
+            ])
+        }
+    };
+
+    const { metadata: { values: MapExtractor({ x, y, z }) } } = data;
+
+    assertSame(100, x);
+    assertSame(200, y);
+    assertSame(300, z);
+}
+
+// Partial extraction from Map
+{
+    const map = new Map([
+        ["a", 1],
+        ["b", 2],
+        ["c", 3],
+        ["d", 4]
+    ]);
+
+    const MapExtractor({ a, c }) = map;
+
+    assertSame(1, a);
+    assertSame(3, c);
+}
+
+// Function parameter with Map extractor
+{
+    function processMap(MapExtractor({ x, y })) {
+        return x + y;
+    }
+
+    const map = new Map([["x", 5], ["y", 10]]);
+    const result = processMap(map);
+
+    assertSame(15, result);
+}
+
+// Empty Map
+{
+    const map = new Map();
+    const MapExtractor({}) = map;
+    // Should succeed with no bindings
+}
+
+// Map in array destructuring
+{
+    const maps = [
+        new Map([["value", 1]]),
+        new Map([["value", 2]]),
+        new Map([["value", 3]])
+    ];
+
+    const [
+        MapExtractor({ value: v1 }),
+        MapExtractor({ value: v2 }),
+        MapExtractor({ value: v3 })
+    ] = maps;
+
+    assertSame(1, v1);
+    assertSame(2, v2);
+    assertSame(3, v3);
+}
+
diff --git a/graal-js/src/com.oracle.truffle.js.test/js/extractors/examples/regexp-extractor.js b/graal-js/src/com.oracle.truffle.js.test/js/extractors/examples/regexp-extractor.js
new file mode 100644
index 00000000000..b99aa3d63e1
--- /dev/null
+++ b/graal-js/src/com.oracle.truffle.js.test/js/extractors/examples/regexp-extractor.js
@@ -0,0 +1,187 @@
+/**
+ * @option js.extractors
+ */
+
+load('../../assert.js');
+
+// Add customMatcher to RegExp.prototype
+// This is potentially a built-in feature as part of Pattern Matching
+RegExp.prototype[Symbol.customMatcher] = function (value) {
+    const match = this.exec(value);
+    return !!match && [match];
+};
+
+const input = '2025-01-02T12:34:56Z';
+
+const IsoDate = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/;
+const IsoTime = /^(?<hours>\d{2}):(?<minutes>\d{2}):(?<seconds>\d{2})$/;
+const IsoDateTime = /^(?<date>[^TZ]+)T(?<time>[^Z]+)Z/;
+
+// Test 1: Basic RegExp extraction with named groups
+{
+    const IsoDateTime({ groups: { date, time } }) = input;
+    assertSame(date, '2025-01-02');
+    assertSame(time, '12:34:56');
+
+    const IsoDate({ groups: { year, month, day } }) = date;
+    assertSame(year, '2025');
+    assertSame(month, '01');
+    assertSame(day, '02');
+
+    const IsoTime({ groups: { hours, minutes, seconds } }) = time;
+    assertSame(hours, '12');
+    assertSame(minutes, '34');
+    assertSame(seconds, '56');
+}
+
+// Test 2: RegExp extraction with indexed groups
+{
+    const IsoDateTime([, date, time]) = input;
+    assertSame(date, '2025-01-02');
+    assertSame(time, '12:34:56');
+}
+
+// Test 3: Nested RegExp extraction
+{
+    const IsoDateTime({
+        groups: {
+            date: IsoDate({ groups: { year, month, day } }),
+            time: IsoTime({ groups: { hours, minutes, seconds } })
+        }
+    }) = input;
+    assertSame(year, '2025');
+    assertSame(month, '01');
+    assertSame(day, '02');
+    assertSame(hours, '12');
+    assertSame(minutes, '34');
+    assertSame(seconds, '56');
+}
+
+// Test 4: Simple pattern matching
+{
+    const EmailPattern = /^([^@]+)@([^@]+)$/;
+    const email = 'user@example.com';
+
+    const EmailPattern([, username, domain]) = email;
+
+    assertSame('user', username);
+    assertSame('example.com', domain);
+}
+
+// Test 5: URL parsing with RegExp
+{
+    const UrlPattern = /^(?<protocol>\w+):\/\/(?<host>[^\/]+)(?<path>\/.*)?$/;
+    const url = 'https://example.com/path/to/resource';
+
+    const UrlPattern({ groups: { protocol, host, path } }) = url;
+
+    assertSame('https', protocol);
+    assertSame('example.com', host);
+    assertSame('/path/to/resource', path);
+}
+
+// Test 6: Phone number parsing
+{
+    const PhonePattern = /^\(?(\d{3})\)?[-.\s]?(\d{3})[-.\s]?(\d{4})$/;
+    const phone = '(555) 123-4567';
+
+    const PhonePattern([, areaCode, exchange, subscriber]) = phone;
+
+    assertSame('555', areaCode);
+    assertSame('123', exchange);
+    assertSame('4567', subscriber);
+}
+
+// Test 7: IPv4 address parsing
+{
+    const IPv4Pattern = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
+    const ip = '192.168.1.1';
+
+    const IPv4Pattern([, octet1, octet2, octet3, octet4]) = ip;
+
+    assertSame('192', octet1);
+    assertSame('168', octet2);
+    assertSame('1', octet3);
+    assertSame('1', octet4);
+}
+
+// Test 8: Function parameter with RegExp extractor
+{
+    const DatePattern = /^(\d{4})-(\d{2})-(\d{2})$/;
+
+    function parseDate(DatePattern([, year, month, day])) {
+        return {
+            year: parseInt(year),
+            month: parseInt(month),
+            day: parseInt(day)
+        };
+    }
+
+    const result = parseDate('2025-12-25');
+
+    assertSame(2025, result.year);
+    assertSame(12, result.month);
+    assertSame(25, result.day);
+}
+
+// Test 9: RegExp with optional groups
+{
+    const OptionalPattern = /^(\w+)(?:\s+(\w+))?$/;
+
+    const OptionalPattern([, first, second]) = 'hello world';
+    assertSame('hello', first);
+    assertSame('world', second);
+
+    const OptionalPattern([, first2, second2]) = 'single';
+    assertSame('single', first2);
+    assertSame(undefined, second2);
+}
+
+// Test 10: Case-insensitive matching
+{
+    const CaseInsensitivePattern = /^(yes|no)$/i;
+
+    const CaseInsensitivePattern([match, value]) = 'YES';
+    assertSame('YES', match);
+    assertSame('YES', value);
+}
+
+// Test 11: Multiple RegExp extractions in object
+{
+    const data = {
+        date: '2025-06-15',
+        time: '09:30:45'
+    };
+
+    const {
+        date: IsoDate({ groups: { year, month, day } }),
+        time: IsoTime({ groups: { hours, minutes, seconds } })
+    } = data;
+
+    assertSame('2025', year);
+    assertSame('06', month);
+    assertSame('15', day);
+    assertSame('09', hours);
+    assertSame('30', minutes);
+    assertSame('45', seconds);
+}
+
+// Test 12: RegExp in array pattern
+{
+    const Pattern = /^(\d+):(\d+)$/;
+    const coordinates = ['10:20', '30:40', '50:60'];
+
+    const [
+        Pattern([, x1, y1]),
+        Pattern([, x2, y2]),
+        Pattern([, x3, y3])
+    ] = coordinates;
+
+    assertSame('10', x1);
+    assertSame('20', y1);
+    assertSame('30', x2);
+    assertSame('40', y2);
+    assertSame('50', x3);
+    assertSame('60', y3);
+}
+
diff --git a/graal-js/src/com.oracle.truffle.js.test/js/extractors/expression-resolution.js b/graal-js/src/com.oracle.truffle.js.test/js/extractors/expression-resolution.js
new file mode 100644
index 00000000000..d201d51d8bb
--- /dev/null
+++ b/graal-js/src/com.oracle.truffle.js.test/js/extractors/expression-resolution.js
@@ -0,0 +1,370 @@
+/**
+ * @option js.extractors
+ */
+
+/**
+ * Extractor Expression Resolution
+ *
+ * Tests different forms of extractor expressions:
+ * - Simple identifiers
+ * - Member expressions (qualified names)
+ * - Contextual references (this, super)
+ * - Dynamic access (computed properties)
+ */
+
+load('../assert.js');
+
+// Simple Identifier Reference
+{
+    class Simple {
+        constructor(value) {
+            this.value = value;
+        }
+
+        static [Symbol.customMatcher](obj) {
+            return [obj.value];
+        }
+    }
+
+    const Simple(x) = new Simple(42);
+    assertSame(42, x);
+}
+
+// Member Expression - Qualified Name
+{
+    const namespace = {
+        Point: class {
+            constructor(x, y) {
+                this.x = x;
+                this.y = y;
+            }
+
+            static [Symbol.customMatcher](point) {
+                return [point.x, point.y];
+            }
+        }
+    };
+
+    const p = new namespace.Point(10, 20);
+    const namespace.Point(x, y) = p;
+
+    assertSame(10, x);
+    assertSame(20, y);
+}
+
+// Member Expression - Nested Qualified Name
+{
+    const deeply = {
+        nested: {
+            module: {
+                Extractor: class {
+                    constructor(value) {
+                        this.value = value;
+                    }
+
+                    static [Symbol.customMatcher](obj) {
+                        return [obj.value];
+                    }
+                }
+            }
+        }
+    };
+
+    const obj = new deeply.nested.module.Extractor("deep");
+    const deeply.nested.module.Extractor(result) = obj;
+
+    assertSame("deep", result);
+}
+
+// Contextual Reference - this
+{
+    class Container {
+        constructor() {
+            this.Extractor = class {
+                constructor(value) {
+                    this.value = value;
+                }
+
+                static [Symbol.customMatcher](obj) {
+                    return [obj.value];
+                }
+            };
+        }
+
+        extract(obj) {
+            const this.Extractor(value) = obj;
+            return value;
+        }
+    }
+
+    const container = new Container();
+    const obj = new container.Extractor("test");
+    const result = container.extract(obj);
+
+    assertSame("test", result);
+}
+
+// Contextual Reference - super (in class context)
+{
+    class Base {
+        static Extractor = class {
+            constructor(value) {
+                this.value = value;
+            }
+
+            static [Symbol.customMatcher](obj) {
+                return [obj.value];
+            }
+        };
+    }
+
+    class Derived extends Base {
+        static extract(obj) {
+            const super.Extractor(value) = obj;
+            return value;
+        }
+    }
+
+    const obj = new Base.Extractor("super");
+    const result = Derived.extract(obj);
+
+    assertSame("super", result);
+}
+
+// Dynamic Access - Computed Property (Array Index)
+{
+    const extractors = [
+        class {
+            constructor(value) {
+                this.value = value;
+            }
+
+            static [Symbol.customMatcher](obj) {
+                return [obj.value];
+            }
+        }
+    ];
+
+    const obj = new extractors[0]("indexed");
+    const extractors[0](result) = obj;
+
+    assertSame("indexed", result);
+}
+
+// Dynamic Access - Computed Property (String Key)
+{
+    const registry = {
+        "custom-extractor": class {
+            constructor(value) {
+                this.value = value;
+            }
+
+            static [Symbol.customMatcher](obj) {
+                return [obj.value];
+            }
+        }
+    };
+
+    const obj = new registry["custom-extractor"]("computed");
+    const registry["custom-extractor"](result) = obj;
+
+    assertSame("computed", result);
+}
+
+// Dynamic Access - Computed Property (Variable)
+{
+    const extractors = {
+        Point: class {
+            constructor(x, y) {
+                this.x = x;
+                this.y = y;
+            }
+
+            static [Symbol.customMatcher](point) {
+                return [point.x, point.y];
+            }
+        },
+        Triple: class {
+            constructor(a, b, c) {
+                this.a = a;
+                this.b = b;
+                this.c = c;
+            }
+
+            static [Symbol.customMatcher](triple) {
+                return [triple.a, triple.b, triple.c];
+            }
+        }
+    };
+
+    const key = "Point";
+    const p = new extractors[key](5, 10);
+    const extractors[key](x, y) = p;
+
+    assertSame(5, x);
+    assertSame(10, y);
+}
+
+// Dynamic Access - Expression as Property
+{
+    const extractors = {
+        ext1: class {
+            constructor(value) {
+                this.value = value;
+            }
+
+            static [Symbol.customMatcher](obj) {
+                return [obj.value];
+            }
+        }
+    };
+
+    function getKey() {
+        return "ext" + 1;
+    }
+
+    const obj = new extractors[getKey()]("dynamic");
+    const extractors[getKey()](result) = obj;
+
+    assertSame("dynamic", result);
+}
+
+// Mixed - Member Expression with Computed Property
+{
+    const module = {
+        extractors: {
+            0: class {
+                constructor(value) {
+                    this.value = value;
+                }
+
+                static [Symbol.customMatcher](obj) {
+                    return [obj.value];
+                }
+            }
+        }
+    };
+
+    const obj = new module.extractors[0]("mixed");
+    const module.extractors[0](result) = obj;
+
+    assertSame("mixed", result);
+}
+
+// Member Expression in Function Parameter
+{
+    const lib = {
+        Point: class {
+            constructor(x, y) {
+                this.x = x;
+                this.y = y;
+            }
+
+            static [Symbol.customMatcher](point) {
+                return [point.x, point.y];
+            }
+        }
+    };
+
+    function process(lib.Point(x, y)) {
+        return x + y;
+    }
+
+    const result = process(new lib.Point(15, 25));
+    assertSame(40, result);
+}
+
+// Computed Property in Function Parameter
+{
+    const extractors = [
+        class {
+            constructor(value) {
+                this.value = value;
+            }
+
+            static [Symbol.customMatcher](obj) {
+                return [obj.value];
+            }
+        }
+    ];
+
+    function extract(extractors[0](value)) {
+        return value * 2;
+    }
+
+    const result = extract(new extractors[0](21));
+    assertSame(42, result);
+}
+
+// this Reference in Object Method
+{
+    const obj = {
+        Extractor: class {
+            constructor(value) {
+                this.value = value;
+            }
+
+            static [Symbol.customMatcher](obj) {
+                return [obj.value];
+            }
+        },
+
+        extract(arg) {
+            const this.Extractor(value) = arg;
+            return value.toUpperCase();
+        }
+    };
+
+    const arg = new obj.Extractor("hello");
+    const result = obj.extract(arg);
+
+    assertSame("HELLO", result);
+}
+
+// Complex Member Expression Chain
+{
+    const a = {
+        b: {
+            c: {
+                d: {
+                    Extractor: class {
+                        constructor(value) {
+                            this.value = value;
+                        }
+
+                        static [Symbol.customMatcher](obj) {
+                            return [obj.value];
+                        }
+                    }
+                }
+            }
+        }
+    };
+
+    const obj = new a.b.c.d.Extractor("chain");
+    const a.b.c.d.Extractor(result) = obj;
+
+    assertSame("chain", result);
+}
+
+// Symbol as Computed Property
+{
+    const sym = Symbol('extractor');
+    const registry = {
+        [sym]: class {
+            constructor(value) {
+                this.value = value;
+            }
+
+            static [Symbol.customMatcher](obj) {
+                return [obj.value];
+            }
+        }
+    };
+
+    const obj = new registry[sym]("symbol");
+    const registry[sym](result) = obj;
+
+    assertSame("symbol", result);
+}
+
diff --git a/graal-js/src/com.oracle.truffle.js.test/js/extractors/receiver-parameter.js b/graal-js/src/com.oracle.truffle.js.test/js/extractors/receiver-parameter.js
new file mode 100644
index 00000000000..51de2cef80d
--- /dev/null
+++ b/graal-js/src/com.oracle.truffle.js.test/js/extractors/receiver-parameter.js
@@ -0,0 +1,269 @@
+/**
+ * @option js.extractors
+ */
+
+/**
+ * Receiver Parameter in CustomMatcher
+ *
+ * Tests that the customMatcher receives the receiver (extractor expression)
+ * as the third parameter when invoked.
+ */
+
+load('../assert.js');
+
+// Receiver Parameter - Basic Access
+{
+    class C {
+        #f;
+        constructor(f) {
+            this.#f = f;
+        }
+        extractor = {
+            [Symbol.customMatcher](subject, _kind, receiver) {
+                return [receiver.#f(subject)];
+            }
+        };
+    }
+
+    const obj = new C(data => data.toUpperCase() + "1234");
+    const subject = "data";
+
+    const obj.extractor(x) = subject;
+
+    assertSame(x, "DATA1234");
+}
+
+// Receiver Parameter - Instance Method Access
+{
+    class Processor {
+        #transform;
+
+        constructor(transform) {
+            this.#transform = transform;
+        }
+
+        get matcher() {
+            return {
+                [Symbol.customMatcher]: (subject, _kind, receiver) => {
+                    return [receiver.#transform(subject)];
+                }
+            };
+        }
+    }
+
+    const processor = new Processor(x => x * 2);
+    const processor.matcher(result) = 5;
+
+    assertSame(10, result);
+}
+
+// Receiver Parameter - Accessing Receiver Properties
+{
+    class Wrapper {
+        constructor(prefix) {
+            this.prefix = prefix;
+        }
+
+        extractor = {
+            [Symbol.customMatcher](subject, _kind, receiver) {
+                return [receiver.prefix + subject];
+            }
+        };
+    }
+
+    const wrapper = new Wrapper("PREFIX:");
+    const wrapper.extractor(value) = "test";
+
+    assertSame("PREFIX:test", value);
+}
+
+// Receiver Parameter - Multiple Receivers
+{
+    class Factory {
+        constructor(multiplier) {
+            this.multiplier = multiplier;
+        }
+
+        get extractor() {
+            return {
+                [Symbol.customMatcher]: (subject, _kind, receiver) => {
+                    return [subject * receiver.multiplier];
+                }
+            };
+        }
+    }
+
+    const factory1 = new Factory(10);
+    const factory2 = new Factory(100);
+
+    const factory1.extractor(x) = 5;
+    const factory2.extractor(y) = 5;
+
+    assertSame(50, x);
+    assertSame(500, y);
+}
+
+// Receiver Parameter - Static vs Instance Context
+{
+    class Extractor {
+        static staticValue = "static";
+        instanceValue = "instance";
+
+        static staticExtractor = {
+            [Symbol.customMatcher](subject, _kind, receiver) {
+                // When accessed as Extractor.staticExtractor, receiver is the class
+                return [receiver.staticValue];
+            }
+        };
+
+        get instanceExtractor() {
+            return {
+                [Symbol.customMatcher]: (subject, _kind, receiver) => {
+                    // When accessed as obj.instanceExtractor, receiver is the instance
+                    return [receiver.instanceValue];
+                }
+            };
+        }
+    }
+
+    const Extractor.staticExtractor(staticResult) = "ignored";
+    assertSame("static", staticResult);
+
+    const obj = new Extractor();
+    const obj.instanceExtractor(instanceResult) = "ignored";
+    assertSame("instance", instanceResult);
+}
+
+// Receiver Parameter - Computed Property Access
+{
+    class Container {
+        #value;
+
+        constructor(value) {
+            this.#value = value;
+        }
+
+        get processor() {
+            return {
+                [Symbol.customMatcher]: (subject, _kind, receiver) => {
+                    return [receiver.#value + subject];
+                }
+            };
+        }
+    }
+
+    const containers = [new Container(10), new Container(100)];
+
+    const containers[0].processor(x) = 5;
+    const containers[1].processor(y) = 5;
+
+    assertSame(15, x);
+    assertSame(105, y);
+}
+
+// Receiver Parameter - Method Call on Receiver
+{
+    class Transformer {
+        transform(value) {
+            return `transformed:${value}`;
+        }
+
+        get extractor() {
+            return {
+                [Symbol.customMatcher]: (subject, _kind, receiver) => {
+                    return [receiver.transform(subject)];
+                }
+            };
+        }
+    }
+
+    const t = new Transformer();
+    const t.extractor(result) = "input";
+
+    assertSame("transformed:input", result);
+}
+
+// Receiver Parameter - Arrow Function Access
+{
+    class Closer {
+        constructor(closure) {
+            this.closure = closure;
+            this.extractor = {
+                [Symbol.customMatcher]: (subject, _kind, receiver) => {
+                    return [receiver.closure(subject)];
+                }
+            };
+        }
+    }
+
+    const closer = new Closer(x => x.split('').reverse().join(''));
+    const closer.extractor(reversed) = "hello";
+
+    assertSame("olleh", reversed);
+}
+
+// Receiver Parameter - Nested Property Access
+{
+    class Config {
+        constructor() {
+            this.settings = {
+                multiplier: 3,
+                offset: 7
+            };
+        }
+
+        get calculator() {
+            return {
+                [Symbol.customMatcher]: (subject, _kind, receiver) => {
+                    return [subject * receiver.settings.multiplier + receiver.settings.offset];
+                }
+            };
+        }
+    }
+
+    const config = new Config();
+    const config.calculator(result) = 10;
+
+    assertSame(37, result); // 10 * 3 + 7
+}
+
+// Receiver Parameter - this Context
+{
+    const obj = {
+        value: 42,
+        extractor: {
+            [Symbol.customMatcher](subject, _kind, receiver) {
+                // receiver should be obj when accessed as obj.extractor
+                return [receiver.value];
+            }
+        }
+    };
+
+    const obj.extractor(x) = "anything";
+    assertSame(42, x);
+}
+
+// Receiver Parameter - Symbol Properties
+{
+    const sym = Symbol('data');
+
+    class SymbolHolder {
+        constructor(data) {
+            this[sym] = data;
+        }
+
+        get extractor() {
+            return {
+                [Symbol.customMatcher]: (subject, _kind, receiver) => {
+                    return [receiver[sym]];
+                }
+            };
+        }
+    }
+
+    const holder = new SymbolHolder("symbol-data");
+    const holder.extractor(data) = "ignored";
+
+    assertSame("symbol-data", data);
+}
+
diff --git a/graal-js/src/com.oracle.truffle.js.test/js/extractors/runtime-evaluation-cleanup.js b/graal-js/src/com.oracle.truffle.js.test/js/extractors/runtime-evaluation-cleanup.js
new file mode 100644
index 00000000000..8a7c99a4e7d
--- /dev/null
+++ b/graal-js/src/com.oracle.truffle.js.test/js/extractors/runtime-evaluation-cleanup.js
@@ -0,0 +1,561 @@
+/**
+ * @option js.extractors
+ */
+
+/**
+ * Runtime Semantics - Evaluation & Cleanup
+ *
+ * Tests the runtime behavior of destructuring and iterator cleanup:
+ * - Destructuring: IteratorBindingInitialization (standard array destructuring)
+ * - Iterator Closing: Ensures iterator.return() is called after binding
+ * - Error Handling: Iterator closing on exceptions during binding
+ *
+ * todo-extractors: There are some commented-out assertions related to iterator return() calls.
+ *  These should be revisited once extractor behavior is finalized.
+ */
+
+load('../assert.js');
+
+// Basic Destructuring: All values consumed
+{
+    let returnCalled = false;
+
+    class BasicMatcher {
+        constructor(...values) {
+            this.values = values;
+        }
+
+        static [Symbol.customMatcher](obj) {
+            let i = 0;
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    if (i < obj.values.length) {
+                        return { value: obj.values[i++], done: false };
+                    }
+                    return { done: true };
+                },
+                return() {
+                    returnCalled = true;
+                    return { done: true };
+                }
+            };
+        }
+    }
+
+    const obj = new BasicMatcher(1, 2, 3);
+    const BasicMatcher(a, b, c) = obj;
+
+    assertSame(1, a);
+    assertSame(2, b);
+    assertSame(3, c);
+    assertTrue(returnCalled, 'Iterator return() should be called');
+}
+
+// Partial Destructuring: Not all values consumed
+{
+    let returnCalled = false;
+
+    class PartialMatcher {
+        constructor(...values) {
+            this.values = values;
+        }
+
+        static [Symbol.customMatcher](obj) {
+            let i = 0;
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    if (i < obj.values.length) {
+                        return { value: obj.values[i++], done: false };
+                    }
+                    return { done: true };
+                },
+                return() {
+                    returnCalled = true;
+                    return { done: true };
+                }
+            };
+        }
+    }
+
+    const obj = new PartialMatcher(1, 2, 3, 4, 5);
+    const PartialMatcher(a, b) = obj;
+
+    assertSame(1, a);
+    assertSame(2, b);
+    assertTrue(returnCalled, 'Iterator return() should be called even with extra values');
+}
+
+// Empty Destructuring: No bindings
+{
+    let returnCalled = false;
+
+    class EmptyMatcher {
+        static [Symbol.customMatcher]() {
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    return { done: true };
+                },
+                return() {
+                    returnCalled = true;
+                    return { done: true };
+                }
+            };
+        }
+    }
+
+    const EmptyMatcher() = new EmptyMatcher();
+    assertTrue(returnCalled, 'Iterator return() should be called even with no bindings');
+}
+
+// Iterator Closing on Error: next() throws
+{
+    let returnCalled = false;
+
+    class ThrowsInNext {
+        static [Symbol.customMatcher]() {
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    throw new Error("fail during iteration");
+                },
+                return() {
+                    returnCalled = true;
+                    return { done: true };
+                }
+            };
+        }
+    }
+
+    let caught = false;
+    try {
+        const ThrowsInNext(x) = new ThrowsInNext();
+        fail('Should have thrown error from next()');
+    } catch (e) {
+        caught = true;
+        // assertTrue(returnCalled, 'Iterator return() should be called on error');
+    }
+    assertTrue(caught, 'Exception should have been thrown');
+}
+
+// Iterator Closing on Error: Binding initialization throws
+{
+    let returnCalled = false;
+
+    class BindingThrows {
+        static [Symbol.customMatcher]() {
+            let count = 0;
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    if (count === 0) {
+                        count++;
+                        return { value: { get x() { throw new Error("getter error"); } }, done: false };
+                    }
+                    return { done: true };
+                },
+                return() {
+                    returnCalled = true;
+                    return { done: true };
+                }
+            };
+        }
+    }
+
+    let caught = false;
+    try {
+        const BindingThrows({ x }) = new BindingThrows();
+        fail('Should have thrown error from getter');
+    } catch (e) {
+        caught = true;
+        assertSame("getter error", e.message);
+        assertTrue(returnCalled, 'Iterator return() should be called on binding error');
+    }
+    assertTrue(caught, 'Exception should have been thrown');
+}
+
+// Iterator without return() method
+{
+    class NoReturnMethod {
+        static [Symbol.customMatcher]() {
+            let i = 0;
+            const values = [1, 2, 3];
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    if (i < values.length) {
+                        return { value: values[i++], done: false };
+                    }
+                    return { done: true };
+                }
+                // No return() method
+            };
+        }
+    }
+
+    // Should not throw even if return() is not defined
+    const NoReturnMethod(a, b, c) = new NoReturnMethod();
+    assertSame(1, a);
+    assertSame(2, b);
+    assertSame(3, c);
+}
+
+// Iterator return() throws error
+{
+    let returnCalled = false;
+
+    class ReturnThrows {
+        static [Symbol.customMatcher]() {
+            let i = 0;
+            const values = [1, 2];
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    if (i < values.length) {
+                        return { value: values[i++], done: false };
+                    }
+                    return { done: true };
+                },
+                return() {
+                    returnCalled = true;
+                    throw new Error("return() error");
+                }
+            };
+        }
+    }
+
+    let caught = false;
+    try {
+        const ReturnThrows(a, b) = new ReturnThrows();
+        fail('Should have thrown error from return()');
+    } catch (e) {
+        caught = true;
+        assertSame("return() error", e.message);
+        assertTrue(returnCalled, 'return() should have been called');
+    }
+    assertTrue(caught, 'Exception should have been thrown');
+}
+
+// Iterator return() returns non-object
+{
+    let returnCalled = false;
+
+    class BadReturnValue {
+        static [Symbol.customMatcher]() {
+            let i = 0;
+            const values = [1, 2];
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    if (i < values.length) {
+                        return { value: values[i++], done: false };
+                    }
+                    return { done: true };
+                },
+                return() {
+                    returnCalled = true;
+                    return null; // Invalid return value
+                }
+            };
+        }
+    }
+
+    let caught = false;
+    try {
+        const BadReturnValue(a, b) = new BadReturnValue();
+        fail('Should have thrown TypeError');
+    } catch (e) {
+        caught = true;
+        assertTrue(e instanceof TypeError, 'Expected TypeError for non-object return value');
+        assertTrue(returnCalled, 'return() should have been called');
+    }
+    assertTrue(caught, 'Exception should have been thrown');
+}
+
+// Default Values in Destructuring
+{
+    let returnCalled = false;
+
+    class WithDefaults {
+        static [Symbol.customMatcher]() {
+            let i = 0;
+            const values = [1];
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    if (i < values.length) {
+                        return { value: values[i++], done: false };
+                    }
+                    return { done: true };
+                },
+                return() {
+                    returnCalled = true;
+                    return { done: true };
+                }
+            };
+        }
+    }
+
+    const WithDefaults(a, b = 99, c = 100) = new WithDefaults();
+    assertSame(1, a);
+    assertSame(99, b);
+    assertSame(100, c);
+    // assertTrue(returnCalled, 'Iterator return() should be called');
+}
+
+// Nested Destructuring with Iterator Cleanup
+{
+    let outerReturnCalled = false;
+    let innerReturnCalled = false;
+
+    class Inner {
+        static [Symbol.customMatcher]() {
+            let i = 0;
+            const values = [10, 20];
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    if (i < values.length) {
+                        return { value: values[i++], done: false };
+                    }
+                    return { done: true };
+                },
+                return() {
+                    innerReturnCalled = true;
+                    return { done: true };
+                }
+            };
+        }
+    }
+
+    class Outer {
+        static [Symbol.customMatcher]() {
+            let i = 0;
+            const values = [new Inner(), 30];
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    if (i < values.length) {
+                        return { value: values[i++], done: false };
+                    }
+                    return { done: true };
+                },
+                return() {
+                    outerReturnCalled = true;
+                    return { done: true };
+                }
+            };
+        }
+    }
+
+    const Outer(Inner(x, y), z) = new Outer();
+    assertSame(10, x);
+    assertSame(20, y);
+    assertSame(30, z);
+    assertTrue(innerReturnCalled, 'Inner iterator return() should be called');
+    assertTrue(outerReturnCalled, 'Outer iterator return() should be called');
+}
+
+// Array Destructuring in Assignment Context
+{
+    let returnCalled = false;
+
+    class AssignMatcher {
+        static [Symbol.customMatcher]() {
+            let i = 0;
+            const values = [100, 200];
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    if (i < values.length) {
+                        return { value: values[i++], done: false };
+                    }
+                    return { done: true };
+                },
+                return() {
+                    returnCalled = true;
+                    return { done: true };
+                }
+            };
+        }
+    }
+
+    let a, b;
+    AssignMatcher(a, b) = new AssignMatcher();
+
+    assertSame(100, a);
+    assertSame(200, b);
+    assertTrue(returnCalled, 'Iterator return() should be called in assignment');
+}
+
+// Iterator Closing in for-of Loop
+{
+    let iterationCount = 0;
+    let returnCalled = false;
+
+    class ForOfMatcher {
+        static [Symbol.customMatcher]() {
+            let i = 0;
+            const values = [1, 2];
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    if (i < values.length) {
+                        return { value: values[i++], done: false };
+                    }
+                    return { done: true };
+                },
+                return() {
+                    returnCalled = true;
+                    return { done: true };
+                }
+            };
+        }
+    }
+
+    const items = [new ForOfMatcher(), new ForOfMatcher()];
+
+    for (const ForOfMatcher(x, y) of items) {
+        iterationCount++;
+        assertTrue(x === 1 || x === 1);
+        assertTrue(y === 2 || y === 2);
+    }
+
+    assertSame(2, iterationCount);
+    assertTrue(returnCalled, 'Iterator return() should be called in for-of');
+}
+
+// Iterator Closing with Rest Element in Pattern
+{
+    let returnCalled = false;
+
+    class RestMatcher {
+        static [Symbol.customMatcher]() {
+            let i = 0;
+            const values = [1, 2, 3, 4, 5];
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    if (i < values.length) {
+                        return { value: values[i++], done: false };
+                    }
+                    return { done: true };
+                },
+                return() {
+                    returnCalled = true;
+                    return { done: true };
+                }
+            };
+        }
+    }
+
+    const RestMatcher(a, b, ...rest) = new RestMatcher();
+    assertSame(1, a);
+    assertSame(2, b);
+    assertSameContent([3, 4, 5], rest);
+    // assertTrue(returnCalled, 'Iterator return() should be called with rest element');
+}
+
+// Multiple Errors: next() throws after partial iteration
+{
+    let returnCalled = false;
+
+    class PartialThenThrow {
+        static [Symbol.customMatcher]() {
+            let count = 0;
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    count++;
+                    if (count === 1) {
+                        return { value: 42, done: false };
+                    }
+                    throw new Error("second next() fails");
+                },
+                return() {
+                    returnCalled = true;
+                    return { done: true };
+                }
+            };
+        }
+    }
+
+    let caught = false;
+    try {
+        const PartialThenThrow(a, b) = new PartialThenThrow();
+        fail('Should have thrown error from second next()');
+    } catch (e) {
+        caught = true;
+        assertSame("second next() fails", e.message);
+        // assertTrue(returnCalled, 'Iterator return() should be called on error');
+    }
+    assertTrue(caught, 'Exception should have been thrown');
+}
+
+// Iterator Closing in Function Parameters
+{
+    let returnCalled = false;
+
+    class ParamMatcher {
+        static [Symbol.customMatcher]() {
+            let i = 0;
+            const values = [5, 10];
+            return {
+                [Symbol.iterator]() {
+                    return this;
+                },
+                next() {
+                    if (i < values.length) {
+                        return { value: values[i++], done: false };
+                    }
+                    return { done: true };
+                },
+                return() {
+                    returnCalled = true;
+                    return { done: true };
+                }
+            };
+        }
+    }
+
+    function testFunc(ParamMatcher(x, y)) {
+        assertSame(5, x);
+        assertSame(10, y);
+    }
+
+    testFunc(new ParamMatcher());
+    assertTrue(returnCalled, 'Iterator return() should be called in function parameters');
+}
+
diff --git a/graal-js/src/com.oracle.truffle.js.test/js/extractors/runtime-invoke-matcher.js b/graal-js/src/com.oracle.truffle.js.test/js/extractors/runtime-invoke-matcher.js
new file mode 100644
index 00000000000..282e3a6a3b8
--- /dev/null
+++ b/graal-js/src/com.oracle.truffle.js.test/js/extractors/runtime-invoke-matcher.js
@@ -0,0 +1,494 @@
+/**
+ * @option js.extractors
+ */
+
+/**
+ * Runtime Semantics - InvokeCustomMatcherOrThrow
+ *
+ * Tests the runtime behavior of custom matcher invocation:
+ * - Type check: extractor must be an Object
+ * - Method resolution: Symbol.customMatcher must exist
+ * - Invocation: matcher is called with the value
+ * - Result type check: matcher result must be an Object
+ * - Iterator retrieval: result must be iterable
+ */
+
+load('../assert.js');
+load('common.js');
+
+// Type Check: Extractor is Not an Object
+{
+    const nonObjectValues = [
+        ['undefined', undefined],
+        ['null', null],
+        ['number', 42],
+        ['string', "string"],
+        ['boolean', true]
+    ];
+
+    for (const [type, value] of nonObjectValues) {
+        let caught = false;
+        try {
+            const Extractor = value;
+            const Extractor(x) = { x: 1 };
+            fail(`Should have thrown TypeError for ${type} extractor`);
+        } catch (e) {
+            caught = true;
+            assertTrue(e instanceof TypeError, `Expected TypeError for ${type} extractor`);
+        }
+        assertTrue(caught, `Exception should have been thrown for ${type}`);
+    }
+}
+
+// Method Resolution: [Symbol.customMatcher] is undefined, null, or not a function
+{
+    const testCases = [
+        ['undefined', class NoMatcher {}],
+        ['null', class NullMatcher { static [Symbol.customMatcher] = null; }],
+        ['not a function', class NotAFunction { static [Symbol.customMatcher] = 42; }]
+    ];
+
+    for (const [description, MatcherClass] of testCases) {
+        let caught = false;
+        try {
+            const MatcherClass(x) = new MatcherClass();
+            fail(`Should have thrown TypeError when customMatcher is ${description}`);
+        } catch (e) {
+            caught = true;
+            assertTrue(e instanceof TypeError, `Expected TypeError when customMatcher is ${description}`);
+        }
+        assertTrue(caught, `Exception should have been thrown for ${description}`);
+    }
+}
+
+// Invocation: Matcher is Called with Correct Value and Can Throw Errors
+{
+    // Test that matcher receives the correct value
+    let receivedValue = null;
+    class ChecksArgument {
+        static [Symbol.customMatcher](value) {
+            receivedValue = value;
+            return [1, 2];
+        }
+    }
+    const testValue = { x: 10, y: 20 };
+    const ChecksArgument(a, b) = testValue;
+    assertSame(testValue, receivedValue, 'Matcher should receive the RHS value');
+    assertSame(1, a);
+    assertSame(2, b);
+
+    // Test that matcher errors are propagated
+    const errorCases = [
+        ['Error', class { static [Symbol.customMatcher]() { throw new Error("matcher error"); } }, "matcher error"],
+        ['TypeError', class { static [Symbol.customMatcher]() { throw new TypeError("custom type error"); } }, "custom type error"]
+    ];
+
+    for (const [type, MatcherClass, expectedMsg] of errorCases) {
+        let caught = false;
+        try {
+            const MatcherClass(x) = new MatcherClass();
+            fail(`Should have propagated ${type}`);
+        } catch (e) {
+            caught = true;
+            assertTrue(e instanceof Error);
+            assertSame(expectedMsg, e.message);
+        }
+        assertTrue(caught, `${type} should have been thrown`);
+    }
+}
+
+// Invocation: Matcher Return Value is Used
+{
+    const Extractor = class {
+        static [Symbol.customMatcher](subject) {
+            // Return a custom array, not derived from subject
+            return [1, 2, 3];
+        }
+    };
+
+    const Extractor(a, b, c) = "any value";
+
+    assertSame(1, a);
+    assertSame(2, b);
+    assertSame(3, c);
+}
+
+// Result Type Check: Matcher Result Must Be an Object
+{
+    const invalidResults = [
+        ['undefined', undefined],
+        ['null', null],
+        ['number', 42],
+        ['string', "string"],
+        ['boolean', true]
+    ];
+
+    for (const [type, result] of invalidResults) {
+        class ReturnsBad {
+            static [Symbol.customMatcher]() {
+                return result;
+            }
+        }
+
+        let caught = false;
+        try {
+            const ReturnsBad(x) = new ReturnsBad();
+            fail(`Should have thrown TypeError when matcher returns ${type}`);
+        } catch (e) {
+            caught = true;
+            assertTrue(e instanceof TypeError, `Expected TypeError when matcher returns ${type}`);
+        }
+        assertTrue(caught, `Exception should have been thrown for ${type}`);
+    }
+}
+
+// Iterator Retrieval: Result is Iterable Array
+{
+    const Extractor = class {
+        static [Symbol.customMatcher](subject) {
+            return [1, 2, 3];
+        }
+    };
+
+    const Extractor(a, b, c) = "value";
+
+    assertSame(1, a);
+    assertSame(2, b);
+    assertSame(3, c);
+}
+
+// Success Case: Proper Invocation with Custom Iterable
+{
+    class CustomIterableMatcher {
+        constructor(val) { this.val = val; }
+        static [Symbol.customMatcher](obj) {
+            return {
+                [Symbol.iterator]() {
+                    let i = 0;
+                    const values = [obj.val, obj.val * 2, obj.val * 3];
+                    return {
+                        next() {
+                            if (i < values.length) {
+                                return { value: values[i++], done: false };
+                            }
+                            return { done: true };
+                        }
+                    };
+                }
+            };
+        }
+    }
+
+    const CustomIterableMatcher(x, y, z) = new CustomIterableMatcher(5);
+    assertSame(5, x);
+    assertSame(10, y);
+    assertSame(15, z);
+}
+
+// Iterator Retrieval: Result is Custom Iterable (alternative implementation)
+{
+    const Extractor = class {
+        static [Symbol.customMatcher](subject) {
+            return {
+                [Symbol.iterator]() {
+                    let i = 0;
+                    return {
+                        next() {
+                            if (i < 3) {
+                                return { value: i++, done: false };
+                            }
+                            return { done: true };
+                        }
+                    };
+                }
+            };
+        }
+    };
+
+    const Extractor(a, b, c) = "value";
+
+    assertSame(0, a);
+    assertSame(1, b);
+    assertSame(2, c);
+}
+
+// Success Case: Matcher with Generator Function
+{
+    class GeneratorMatcher {
+        constructor(...values) {
+            this.values = values;
+        }
+
+        static [Symbol.customMatcher](obj) {
+            return {
+                *[Symbol.iterator]() {
+                    yield* obj.values;
+                }
+            };
+        }
+    }
+
+    const GeneratorMatcher(a, b, c) = new GeneratorMatcher(7, 8, 9);
+    assertSame(7, a);
+    assertSame(8, b);
+    assertSame(9, c);
+}
+
+// Iterator Retrieval: Result is Generator (alternative implementation)
+{
+    const Extractor = class {
+        static [Symbol.customMatcher](subject) {
+            return (function*() {
+                yield 10;
+                yield 20;
+                yield 30;
+            })();
+        }
+    };
+
+    const Extractor(a, b, c) = "value";
+
+    assertSame(10, a);
+    assertSame(20, b);
+    assertSame(30, c);
+}
+
+// Iterator Retrieval: Matcher Result Must Be Iterable
+{
+    const invalidIterableCases = [
+        ['no Symbol.iterator', {}],
+        ['Symbol.iterator not a function', { [Symbol.iterator]: 42 }],
+        ['Symbol.iterator returns null', { [Symbol.iterator]() { return null; } }]
+    ];
+
+    for (const [description, result] of invalidIterableCases) {
+        class BadIterable {
+            static [Symbol.customMatcher]() {
+                return result;
+            }
+        }
+
+        let caught = false;
+        try {
+            const BadIterable(x) = new BadIterable();
+            fail(`Should have thrown TypeError: ${description}`);
+        } catch (e) {
+            caught = true;
+            assertTrue(e instanceof TypeError, `Expected TypeError: ${description}`);
+        }
+        assertTrue(caught, `Exception should have been thrown: ${description}`);
+    }
+}
+
+// Success Case: Proper Invocation and Binding with Array
+{
+    class ArrayMatcher {
+        constructor(val) { this.val = val; }
+        static [Symbol.customMatcher](obj) {
+            return [obj.val, obj.val + 1];
+        }
+    }
+
+    const ArrayMatcher(a, b) = new ArrayMatcher(10);
+    assertSame(10, a);
+    assertSame(11, b);
+}
+
+// Success Case: Matcher Accessing Object Properties
+{
+    class Point {
+        constructor(x, y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        static [Symbol.customMatcher](point) {
+            return [point.x, point.y];
+        }
+    }
+
+    const Point(px, py) = new Point(100, 200);
+    assertSame(100, px);
+    assertSame(200, py);
+}
+
+// Matcher Accesses Subject Properties (using common Pair)
+{
+    const Pair(x, y) = new Pair(100, 200);
+
+    assertSame(100, x);
+    assertSame(200, y);
+}
+
+// Matcher Uses Private Fields
+{
+    class Wrapper {
+        #value;
+
+        constructor(value) {
+            this.#value = value;
+        }
+
+        static [Symbol.customMatcher](subject) {
+            // Check for private field and return its value
+            if (#value in subject) {
+                return [subject.#value];
+            }
+            throw new Error("Invalid subject");
+        }
+    }
+
+    const Wrapper(x) = new Wrapper("private");
+    assertSame("private", x);
+}
+
+// Success Case: Matcher Returning Empty Iterable
+{
+    class EmptyMatcher {
+        static [Symbol.customMatcher]() {
+            return [];
+        }
+    }
+
+    const EmptyMatcher() = new EmptyMatcher();
+    // No bindings, should succeed
+}
+
+// Matcher Returns Empty Array (alternative test)
+{
+    const EmptyExtractor = class {
+        static [Symbol.customMatcher](subject) {
+            return [];
+        }
+    };
+
+    // Empty pattern should work
+    const EmptyExtractor() = "value";
+    assertTrue(true); // Just verify no error
+}
+
+// Matcher Returns Array with Insufficient Elements
+{
+    const InsufficientExtractor = class {
+        static [Symbol.customMatcher](subject) {
+            return [1]; // Only one element
+        }
+    };
+
+    // Destructuring with more variables than values
+    const InsufficientExtractor(a, b, c) = "value";
+
+    assertSame(1, a);
+    assertSame(undefined, b); // Should be undefined
+    assertSame(undefined, c); // Should be undefined
+}
+
+// Success Case: Matcher with More Values Than Bindings
+{
+    class ExtraMatcher {
+        static [Symbol.customMatcher]() {
+            return [1, 2, 3, 4, 5];
+        }
+    }
+
+    const ExtraMatcher(a, b) = new ExtraMatcher();
+    assertSame(1, a);
+    assertSame(2, b);
+    // Extra values are ignored
+}
+
+// Matcher Returns Array with Extra Elements (alternative test)
+{
+    const ExtraExtractor = class {
+        static [Symbol.customMatcher](subject) {
+            return [1, 2, 3, 4, 5];
+        }
+    };
+
+    // Only destructure first two
+    const ExtraExtractor(a, b) = "value";
+
+    assertSame(1, a);
+    assertSame(2, b);
+    // Extra elements are ignored
+}
+
+// Matcher is Called Once Per Extraction
+{
+    let callCount = 0;
+
+    const CountingExtractor = class {
+        static [Symbol.customMatcher](subject) {
+            callCount++;
+            return [callCount];
+        }
+    };
+
+    const CountingExtractor(x) = "value";
+    assertSame(1, x);
+    assertSame(1, callCount); // Called exactly once
+}
+
+// Different Subjects Call Matcher with Different Values
+{
+    const values = [];
+
+    const RecordingExtractor = class {
+        static [Symbol.customMatcher](subject) {
+            values.push(subject);
+            return [subject];
+        }
+    };
+
+    const RecordingExtractor(a) = "first";
+    const RecordingExtractor(b) = "second";
+
+    assertSame("first", a);
+    assertSame("second", b);
+    assertSameContent(["first", "second"], values);
+}
+
+// Matcher Returns Object with Symbol.iterator
+{
+    const CustomIterableExtractor = class {
+        static [Symbol.customMatcher](subject) {
+            return {
+                data: [5, 10, 15],
+                [Symbol.iterator]() {
+                    let index = 0;
+                    const data = this.data;
+                    return {
+                        next() {
+                            if (index < data.length) {
+                                return { value: data[index++], done: false };
+                            }
+                            return { done: true };
+                        }
+                    };
+                }
+            };
+        }
+    };
+
+    const CustomIterableExtractor(a, b, c) = "value";
+
+    assertSame(5, a);
+    assertSame(10, b);
+    assertSame(15, c);
+}
+
+// Matcher with This Context
+{
+    const ExtractorWithThis = class {
+        static data = "static-data";
+
+        static [Symbol.customMatcher](subject) {
+            // 'this' should refer to the class
+            return [this.data];
+        }
+    };
+
+    const ExtractorWithThis(x) = "value";
+    assertSame("static-data", x);
+}
+
diff --git a/graal-js/src/com.oracle.truffle.js.test/js/extractors/syntactic-validity.js b/graal-js/src/com.oracle.truffle.js.test/js/extractors/syntactic-validity.js
new file mode 100644
index 00000000000..f274a4e98aa
--- /dev/null
+++ b/graal-js/src/com.oracle.truffle.js.test/js/extractors/syntactic-validity.js
@@ -0,0 +1,483 @@
+/**
+ * @option js.extractors
+ */
+
+/**
+ * Syntactic Validity & Locations
+ *
+ * Tests that extractors are supported in all valid pattern contexts:
+ * - Variable declarations (const, let, var)
+ * - Assignments
+ * - Function parameters (declarations, expressions, arrows, methods)
+ * - Iteration (for-of, for-await-of, for-in, for loops)
+ * - Exception handling (catch clauses)
+ * - Nesting (inside arrays and objects)
+ * - Recursive composition (extractors inside extractors)
+ *
+ * Also tests that extractors are rejected in invalid contexts:
+ * - Expression positions (non-pattern contexts)
+ * - As rest elements
+ * - Other syntactically invalid positions
+ */
+
+load("../assert.js");
+load("common.js");
+
+// Variable Declarations
+{
+    const p = new Pair(1, 2);
+
+    const Pair(x1, y1) = p;
+    assertSame(1, x1);
+    assertSame(2, y1);
+
+    let Pair(x2, y2) = p;
+    assertSame(1, x2);
+    assertSame(2, y2);
+
+    var Pair(x3, y3) = p;
+    assertSame(1, x3);
+    assertSame(2, y3);
+}
+
+// Assignments
+{
+    const p = new Pair(3, 4);
+    let a, b;
+
+    Pair(a, b) = p;
+    assertSame(3, a);
+    assertSame(4, b);
+}
+
+// Function Parameters - Function Declarations
+{
+    function declFunc(Pair(x, y)) {
+        return x + y;
+    }
+
+    const result = declFunc(new Pair(5, 6));
+    assertSame(11, result);
+}
+
+// Function Parameters - Function Expressions
+{
+    const exprFunc = function(Pair(x, y)) {
+        return x * y;
+    };
+
+    const result = exprFunc(new Pair(7, 8));
+    assertSame(56, result);
+}
+
+// Function Parameters - Arrow Functions (with parentheses)
+{
+    const arrowFunc = (Pair(x, y)) => x - y;
+
+    const result = arrowFunc(new Pair(10, 3));
+    assertSame(7, result);
+}
+
+// Function Parameters - Class Methods
+{
+    class Calculator {
+        add(Pair(x, y)) {
+            return x + y;
+        }
+
+        static multiply(Pair(x, y)) {
+            return x * y;
+        }
+    }
+
+    const calc = new Calculator();
+    assertSame(15, calc.add(new Pair(7, 8)));
+    assertSame(42, Calculator.multiply(new Pair(6, 7)));
+}
+
+// Function Parameters - Class Constructors
+{
+    class PairHolder {
+        constructor(Pair(x, y)) {
+            this.x = x;
+            this.y = y;
+        }
+    }
+
+    const holder = new PairHolder(new Pair(11, 12));
+    assertSame(11, holder.x);
+    assertSame(12, holder.y);
+}
+
+// Function Parameters - Class Setters
+{
+    class PairStorage {
+        #x;
+        #y;
+
+        set point(Pair(x, y)) {
+            this.#x = x;
+            this.#y = y;
+        }
+
+        get sum() {
+            return this.#x + this.#y;
+        }
+    }
+
+    const storage = new PairStorage();
+    storage.point = new Pair(13, 14);
+    assertSame(27, storage.sum);
+}
+
+// Function Parameters - Object Literal Methods
+{
+    const obj = {
+        process(Pair(x, y)) {
+            return { x, y };
+        }
+    };
+
+    const result = obj.process(new Pair(15, 16));
+    assertSame(15, result.x);
+    assertSame(16, result.y);
+}
+
+// Iteration - for-of
+{
+    const points = [new Pair(1, 2), new Pair(3, 4), new Pair(5, 6)];
+    const xs = [];
+    const ys = [];
+
+    for (const Pair(x, y) of points) {
+        xs.push(x);
+        ys.push(y);
+    }
+
+    assertSameContent([1, 3, 5], xs);
+    assertSameContent([2, 4, 6], ys);
+}
+
+// Iteration - for-await-of
+{
+    async function testForAwaitOf() {
+        async function* pointGenerator() {
+            yield new Pair(7, 8);
+            yield new Pair(9, 10);
+        }
+
+        const xs = [];
+        const ys = [];
+
+        for await (const Pair(x, y) of pointGenerator()) {
+            xs.push(x);
+            ys.push(y);
+        }
+
+        assertSameContent([7, 9], xs);
+        assertSameContent([8, 10], ys);
+    }
+
+    testForAwaitOf();
+}
+
+// Iteration - for-in
+{
+    const obj = {
+        p1: new Pair(11, 12),
+        p2: new Pair(13, 14)
+    };
+
+    // Note: for-in uses string keys, not the values directly
+    // This tests that the syntax is valid, even if semantically unusual
+    const keys = [];
+    for (const key in obj) {
+        keys.push(key);
+    }
+
+    assertTrue(keys.includes('p1'));
+    assertTrue(keys.includes('p2'));
+}
+
+// Iteration - Standard for Loop Headers
+{
+    const Pair(initX, initY) = new Pair(100, 200);
+    assertSame(100, initX);
+    assertSame(200, initY);
+}
+
+// Exception Handling -   Clauses
+{
+    class ErrorWrapper {
+        constructor(error) {
+            this.error = error;
+        }
+
+        static [Symbol.customMatcher](wrapper) {
+            return [wrapper.error];
+        }
+    }
+
+    try {
+        throw new ErrorWrapper(new Error("test error"));
+    } catch (ErrorWrapper(e)) {
+        assertSame("test error", e.message);
+    }
+}
+
+// Nesting - Inside Array Destructuring
+{
+    const p = new Pair(17, 18);
+    const [Pair(x, y), other, somethingElse] = [p, "value", 1];
+
+    assertSame(17, x);
+    assertSame(18, y);
+    assertSame("value", other);
+    assertSame(1, somethingElse);
+}
+
+// Nesting - Inside Object Destructuring
+{
+    const p = new Pair(19, 20);
+    const { point: Pair(x, y), name } = { point: p, name: "test" };
+
+    assertSame(19, x);
+    assertSame(20, y);
+    assertSame("test", name);
+}
+
+// Nesting - Deep Object Destructuring
+{
+    const p = new Pair(21, 22);
+    const { a: { b: { c: Pair(x, y) } } } = { a: { b: { c: p } } };
+
+    assertSame(21, x);
+    assertSame(22, y);
+}
+
+// Recursive Composition - Extractor Inside Extractor
+{
+    const line = new Pair(new Pair(1, 2), new Pair(3, 4));
+    const Pair(Pair(x1, y1), Pair(x2, y2)) = line;
+
+    assertSame(1, x1);
+    assertSame(2, y1);
+    assertSame(3, x2);
+    assertSame(4, y2);
+}
+
+// Recursive Composition - Multiple Levels
+{
+    class Container {
+        constructor(value) {
+            this.value = value;
+        }
+
+        static [Symbol.customMatcher](container) {
+            return [container.value];
+        }
+    }
+
+    const nested = new Container(new Pair(new Pair(5, 6), new Pair(7, 8)));
+    const Container(Pair(Pair(x1, y1), Pair(x2, y2))) = nested;
+
+    assertSame(5, x1);
+    assertSame(6, y1);
+    assertSame(7, x2);
+    assertSame(8, y2);
+}
+
+// Nesting - Extractor in Array with Rest Element
+{
+    const t = new Triple(1, 2, 3);
+    const [Triple(a, b, c), ...rest] = [t, 4, 5, 6];
+
+    assertSame(1, a);
+    assertSame(2, b);
+    assertSame(3, c);
+    assertSameContent([4, 5, 6], rest);
+}
+
+// Complex Nesting - Arrays and Objects Combined
+{
+    const p1 = new Pair(23, 24);
+    const p2 = new Pair(25, 26);
+
+    const [{ points: [Pair(x1, y1), Pair(x2, y2)] }] = [{ points: [p1, p2] }];
+
+    assertSame(23, x1);
+    assertSame(24, y1);
+    assertSame(25, x2);
+    assertSame(26, y2);
+}
+
+// Multiple Parameters with Extractors
+{
+    function multiParam(Pair(x1, y1), Pair(x2, y2), Pair(x3, y3)) {
+        return x1 + x2 + x3 + y1 + y2 + y3;
+    }
+
+    const result = multiParam(new Pair(1, 2), new Pair(3, 4), new Pair(5, 6));
+    assertSame(21, result);
+}
+
+// Default Parameters with Extractors
+{
+    function withDefaults(Pair(x, y) = new Pair(0, 0)) {
+        return { x, y };
+    }
+
+    const result1 = withDefaults(new Pair(27, 28));
+    assertSame(27, result1.x);
+    assertSame(28, result1.y);
+
+    const result2 = withDefaults();
+    assertSame(0, result2.x);
+    assertSame(0, result2.y);
+}
+
+// Rest Parameters After Extractor
+{
+    function withRest(Pair(x, y), ...args) {
+        return { x, y, args };
+    }
+
+    const result = withRest(new Pair(29, 30), 'a', 'b', 'c');
+    assertSame(29, result.x);
+    assertSame(30, result.y);
+    assertSameContent(['a', 'b', 'c'], result.args);
+}
+
+// Negative Test: Extractor in Expression Position (not a pattern)
+{
+    assertThrows(() => {
+        eval("const x = PlainObjectWithCustomMatcher({ a: 1 });");
+    });
+}
+
+// Negative Test: Extractor as Standalone Expression
+{
+    assertThrows(() => {
+        eval("PlainObjectWithCustomMatcher({ a: 1 })");
+    });
+}
+
+// Negative Test: Extractor in Return Statement
+{
+    assertThrows(() => {
+        eval("function f() { return PlainObjectWithCustomMatcher({ a: 1 }); }; f();");
+    });
+}
+
+// Negative Test: Extractor in Conditional Expression
+{
+    assertThrows(() => {
+        eval("const x = true ? PlainObjectWithCustomMatcher({ a: 1 }) : 2;");
+    });
+}
+
+// Negative Test: Extractor as Function Call Argument (non-destructuring)
+{
+    assertThrows(() => {
+        eval("console.log(Pair(x));");
+    });
+}
+
+// Negative Test: Extractor Used as Rest Element
+{
+    // [...Foo()] is invalid - rest elements cannot be extractors
+    assertThrows(() => {
+        eval("const [...Pair(x, y)] = [new Pair(1, 2)];");
+    });
+}
+
+// Negative Test: Extractor as Object Rest Element
+{
+    assertThrows(() => {
+        eval("const {...Pair(x, y)} = { a: new Pair(1, 2) };");
+    });
+}
+
+// Negative Test: Extractor in Array Rest Position
+{
+    assertThrows(() => {
+        eval("const [a, ...Pair(x, y)] = [1, new Pair(2, 3)];");
+    });
+}
+
+// Negative Test: Extractor with Spread Operator in Call
+{
+    assertThrows(() => {
+        eval("func(...Pair(x, y));");
+    });
+}
+
+// Negative Test: Extractor in Binary Expression
+{
+    assertThrows(() => {
+        eval("const x = Pair(a, b) + 5;");
+    });
+}
+
+// Negative Test: Extractor in Member Expression Chain
+{
+    assertThrows(() => {
+        eval("const x = Pair(a, b).property;");
+    });
+}
+
+// Negative Test: Extractor as Array Element (not pattern)
+{
+    assertThrows(() => {
+        eval("const arr = [Pair(x, y)];");
+    });
+}
+
+// Negative Test: Extractor as Object Property Value (not pattern)
+{
+    assertThrows(() => {
+        eval("const obj = { prop: Pair(x, y) };");
+    });
+}
+
+// Negative Test: Extractor in typeof Expression
+{
+    assertThrows(() => {
+        eval("const x = typeof Pair(y);");
+    });
+}
+
+// Negative Test: Extractor in Unary Expression
+{
+    assertThrows(() => {
+        eval("const x = !Pair(y);");
+    });
+}
+
+// Negative Test: Extractor in Logical Expression
+{
+    assertThrows(() => {
+        eval("const x = Pair(a) && Pair(b);");
+    });
+}
+
+// Negative Test: Extractor in Template Literal
+{
+    assertThrows(() => {
+        eval("const x = `value: ${Pair(y)}`;");
+    });
+}
+
+// Negative Test: Extractor in New Expression
+{
+    assertThrows(() => {
+        eval("const x = new Pair(Pair(a, b));");
+    });
+}
+
+// Negative Test: Extractor as Class Name
+{
+    assertThrows(() => {
+        eval("class Pair(x, y) {}");
+    });
+}
diff --git a/graal-js/src/com.oracle.truffle.js.test/src/com/oracle/truffle/js/test/parser/ExtractorsParsingTest.java b/graal-js/src/com.oracle.truffle.js.test/src/com/oracle/truffle/js/test/parser/ExtractorsParsingTest.java
new file mode 100644
index 00000000000..f292f1f8441
--- /dev/null
+++ b/graal-js/src/com.oracle.truffle.js.test/src/com/oracle/truffle/js/test/parser/ExtractorsParsingTest.java
@@ -0,0 +1,320 @@
+/*
+ * Copyright (c) 2016, 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.oracle.truffle.js.test.parser;
+
+import com.oracle.truffle.js.runtime.JSContextOptions;
+import org.graalvm.polyglot.Context;
+import org.graalvm.polyglot.PolyglotException;
+import org.graalvm.polyglot.Source;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import com.oracle.truffle.js.test.JSTest;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+public class ExtractorsParsingTest {
+    private Source srcWithBasicCustomMatcher(String code) {
+        final var src = Source.newBuilder("js", """                            
+                class Foo {
+                    static [Symbol.customMatcher](subject) {
+                        return [subject.someRandomProp];
+                    }
+                
+                    someRandomProp = 42;
+                
+                    constructor() {}
+                }
+                
+                class Bar {
+                    static [Symbol.customMatcher](subject) {
+                        return [1, 2, 3];
+                    }
+                }
+                
+                class Pair {
+                    constructor(first, second) {
+                        this.first = first;
+                        this.second = second;
+                    }
+                
+                    static [Symbol.customMatcher](pair) {
+                        return [pair.first, pair.second];
+                    }
+                }
+                
+                """ + code, "test").buildLiteral();
+
+        return src;
+    }
+
+    @Test
+    public void testBasicExtractorBinding() {
+        try (Context ctx = JSTest.newContextBuilder().option(JSContextOptions.EXTRACTORS_NAME, "true").build()) {
+            final var src = srcWithBasicCustomMatcher("""
+                    const foo = new Foo();
+                    
+                    let x;
+                    Foo(x) = foo;
+                    """);
+            ctx.eval(src);
+        }
+    }
+
+    @Test
+    public void testBasicExtractorLetAssignment() {
+        try (Context ctx = JSTest.newContextBuilder().option(JSContextOptions.EXTRACTORS_NAME, "true").build()) {
+            final var src = srcWithBasicCustomMatcher("""
+                    const subject = new Foo();
+                    
+                    let Foo(x) = subject;
+                    """);
+            ctx.eval(src);
+        }
+    }
+
+    @Test
+    public void testBasicExtractorConstAssignment() {
+        try (Context ctx = JSTest.newContextBuilder().option(JSContextOptions.EXTRACTORS_NAME, "true").build()) {
+            final var src = srcWithBasicCustomMatcher("""
+                    const subject = new Foo();
+                    
+                    const Foo(x) = subject;
+                    """);
+            ctx.eval(src);
+        }
+    }
+
+    @Test
+    public void testNestedExtractor() {
+        try (Context ctx = JSTest.newContextBuilder().option(JSContextOptions.EXTRACTORS_NAME, "true").build()) {
+            final var src = Source.newBuilder("js", """
+                    class C {
+                        #f;
+                        constructor(f) {
+                            this.#f = f;
+                        }
+                        extractor = {
+                            [Symbol.customMatcher](subject, _kind, receiver) {
+                                return [receiver.#f(subject)];
+                            }
+                        };
+                    }
+                    
+                    const obj = new C(data => data.toUpperCase());
+                    const subject = "data";
+                    
+                    const obj.extractor(x) = subject;
+                    """, "test").buildLiteral();
+            ctx.eval(src);
+        }
+    }
+
+    // todo-extractors: fix & enable
+    @Ignore
+    @Test
+    public void testNewlineAfterMemberExpression() {
+        try (Context ctx = JSTest.newContextBuilder().option(JSContextOptions.EXTRACTORS_NAME, "true").build()) {
+            final var src = Source.newBuilder("js", """                 
+                    class C {
+                        #data;
+                        constructor(data) {
+                            this.#data = data;
+                        }
+                        static [Symbol.customMatcher](subject) {
+                            return #data in subject && [subject.#data];
+                        }
+                    }
+                    
+                    const subject = new C("data");
+                    
+                    let C
+                    (y) = subject;
+                    """, "test").buildLiteral();
+            final var value = ctx.eval(src);
+            assertTrue(value.isException());
+        }
+    }
+
+    @Test
+    public void testInvalidExtractorBindingsNew() {
+        try (Context ctx = JSTest.newContextBuilder().option(JSContextOptions.EXTRACTORS_NAME, "true").build()) {
+            final var src = srcWithBasicCustomMatcher("""
+                    const subject = new Foo();
+                    
+                    let new Foo(x, y) = subject;
+                    """);
+            ctx.eval(src);
+            fail("Expected SyntaxError");
+        } catch (PolyglotException e) {
+            if (e.isInternalError()) {
+                throw e;
+            } else {
+                Assert.assertTrue("SyntaxError", e.isSyntaxError());
+            }
+        }
+    }
+
+    @Test
+    public void testWithObjectDestructuring() {
+        try (Context ctx = JSTest.newContextBuilder().option(JSContextOptions.EXTRACTORS_NAME, "true").build()) {
+            final var src = srcWithBasicCustomMatcher("""
+                    const subject = { a: 1, b: 2 };
+
+                    const { a: Foo(x), b: Foo(y) } = subject;
+                    """);
+            ctx.eval(src);
+        }
+    }
+
+    @Test
+    public void testWithArrayDestructuring() {
+        try (Context ctx = JSTest.newContextBuilder().option(JSContextOptions.EXTRACTORS_NAME, "true").build()) {
+            final var src = srcWithBasicCustomMatcher("""
+                    const p = new Pair(17, 18);
+                    const [Pair(x), other, somethingElse] = [p, "value", 1];
+                    if (x !== 17 || other !== "value" || somethingElse !== 1) {
+                        throw new Error("Destructuring with extractor failed: " + x + ", " + other + ", " + somethingElse);
+                    }
+                    """);
+            final var value = ctx.eval(src);
+            assertTrue(value.isNull());
+        }
+    }
+
+    @Test
+    public void testAsFunctionParameter() {
+        try (Context ctx = JSTest.newContextBuilder().option(JSContextOptions.EXTRACTORS_NAME, "true").build()) {
+            final var src = srcWithBasicCustomMatcher("""
+                    const o1 = [1, { o2: { Foo } }]
+                    
+                    function f(o1[1].o2.Foo(a)) {}
+                    f(1);
+                    
+                    async function af(o1[1].o2.Foo(a)) {}
+                    af(1);
+                    """);
+            ctx.eval(src);
+        }
+    }
+
+    @Test
+    public void testAsFunctionParameterInArrowFunction() {
+        try (Context ctx = JSTest.newContextBuilder().option(JSContextOptions.EXTRACTORS_NAME, "true").build()) {
+            final var src = srcWithBasicCustomMatcher("""
+                    const o1 = [1, { o2: { Foo } }]
+
+                    const f = (o1[1].o2.Foo(a)) => {};
+                    f(1);
+
+                    const af = async (o1[1].o2.Foo(a)) => {};
+                    af(1);
+                    """);
+            ctx.eval(src);
+        }
+    }
+
+    @Test
+    public void testAsCatchBinding() {
+        try (Context ctx = JSTest.newContextBuilder().option(JSContextOptions.EXTRACTORS_NAME, "true").build()) {
+            final var src = srcWithBasicCustomMatcher("""
+                    try {
+                        throw new Foo();
+                    } catch (Foo(e)) {
+                    }
+                    """);
+            ctx.eval(src);
+        }
+    }
+
+    @Test
+    public void negativeTestAsRestElement() {
+        try (Context ctx = JSTest.newContextBuilder().option(JSContextOptions.EXTRACTORS_NAME, "true").build()) {
+            final var src = srcWithBasicCustomMatcher("""
+                    const subject = [new Foo(), new Foo(), new Foo()];
+
+                    const [...Foo(x)] = [subject];
+                    """);
+            ctx.eval(src);
+            fail("Expected error");
+        } catch (PolyglotException e) {
+            if (e.isInternalError()) {
+                throw e;
+            } else {
+                Assert.assertTrue("SyntaxError", e.isSyntaxError());
+            }
+        }
+
+        try (Context ctx = JSTest.newContextBuilder().option(JSContextOptions.EXTRACTORS_NAME, "true").build()) {
+            final var src = srcWithBasicCustomMatcher("""
+                    const subject = [new Foo(), new Foo(), new Foo()];
+
+                    const {...Foo(x)} = {subject};
+                    """);
+            ctx.eval(src);
+            fail("Expected error");
+        } catch (PolyglotException e) {
+            if (e.isInternalError()) {
+                throw e;
+            } else {
+                Assert.assertTrue("SyntaxError", e.isSyntaxError());
+            }
+        }
+
+        try (Context ctx = JSTest.newContextBuilder().option(JSContextOptions.EXTRACTORS_NAME, "true").build()) {
+            final var src = srcWithBasicCustomMatcher("""
+                    function f(...Foo(x)) {}
+                    f([new Foo()]);
+                    """);
+            ctx.eval(src);
+            fail("Expected error");
+        } catch (PolyglotException e) {
+            if (e.isInternalError()) {
+                throw e;
+            } else {
+                Assert.assertTrue("SyntaxError", e.isSyntaxError());
+            }
+        }
+    }
+}
diff --git a/graal-js/src/com.oracle.truffle.js.test/src/com/oracle/truffle/js/test/suite/JSExtractorsTestSuite.java b/graal-js/src/com.oracle.truffle.js.test/src/com/oracle/truffle/js/test/suite/JSExtractorsTestSuite.java
new file mode 100644
index 00000000000..6037f9d2a71
--- /dev/null
+++ b/graal-js/src/com.oracle.truffle.js.test/src/com/oracle/truffle/js/test/suite/JSExtractorsTestSuite.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2020, 2021, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.oracle.truffle.js.test.suite;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(JSTestRunner.class)
+@JSTestSuite(JSExtractorsTestSuite.PATH_OF_RESOURCES)
+public class JSExtractorsTestSuite {
+
+    public static final String PATH_OF_RESOURCES = "src/com.oracle.truffle.js.test/js-extractors";
+
+    public static void main(String[] args) throws Exception {
+        JSTestRunner.runInMain(JSExtractorsTestSuite.class, args);
+    }
+
+    /*
+     * Our "mx unittest" command looks for methods that are annotated with @Test. By just defining
+     * an empty method, this class gets included and the test suite is properly executed.
+     */
+    @Test
+    public void unittest() {
+    }
+}
diff --git a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/nodes/NodeFactory.java b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/nodes/NodeFactory.java
index 91e48c041ad..e9c4e0300b8 100644
--- a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/nodes/NodeFactory.java
+++ b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/nodes/NodeFactory.java
@@ -202,6 +202,7 @@
 import com.oracle.truffle.js.nodes.control.WhileNode;
 import com.oracle.truffle.js.nodes.control.WithNode;
 import com.oracle.truffle.js.nodes.control.YieldNode;
+import com.oracle.truffle.js.nodes.extractor.InvokeCustomMatcherOrThrowNode;
 import com.oracle.truffle.js.nodes.function.AbstractBodyNode;
 import com.oracle.truffle.js.nodes.function.AbstractFunctionArgumentsNode;
 import com.oracle.truffle.js.nodes.function.BlockScopeNode;
@@ -1390,6 +1391,10 @@ public JavaScriptNode createToObjectForWithStatement(JSContext context, JavaScri
         }
     }
 
+    public JavaScriptNode createInvokeCustomMatcherOrThrow(JSContext context, JavaScriptNode matcher, JavaScriptNode subject, JavaScriptNode receiver, boolean isStrict) {
+        return InvokeCustomMatcherOrThrowNode.create(context, matcher, subject, receiver, isStrict);
+    }
+
     // #####
 
     public static NodeFactory getDefaultInstance() {
diff --git a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/nodes/extractor/InvokeCustomMatcherOrThrowNode.java b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/nodes/extractor/InvokeCustomMatcherOrThrowNode.java
new file mode 100644
index 00000000000..d007e37e15d
--- /dev/null
+++ b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/nodes/extractor/InvokeCustomMatcherOrThrowNode.java
@@ -0,0 +1,89 @@
+package com.oracle.truffle.js.nodes.extractor;
+
+import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.Executed;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.profiles.InlinedBranchProfile;
+import com.oracle.truffle.js.nodes.JavaScriptNode;
+import com.oracle.truffle.js.nodes.access.GetIteratorNode;
+import com.oracle.truffle.js.nodes.access.GetMethodNode;
+import com.oracle.truffle.js.nodes.access.IsObjectNode;
+import com.oracle.truffle.js.nodes.function.JSFunctionCallNode;
+import com.oracle.truffle.js.runtime.Errors;
+import com.oracle.truffle.js.runtime.JSArguments;
+import com.oracle.truffle.js.runtime.JSContext;
+import com.oracle.truffle.js.runtime.Symbol;
+import com.oracle.truffle.js.runtime.objects.IteratorRecord;
+import com.oracle.truffle.js.runtime.objects.Undefined;
+
+/**
+ * https://tc39.es/proposal-extractors/#sec-invokecustommatcherorthrow
+ */
+public abstract class InvokeCustomMatcherOrThrowNode extends JavaScriptNode {
+    @Child private GetMethodNode getCustomMatcherNode;
+    @Child private JSFunctionCallNode callNode;
+
+    @Child @Executed JavaScriptNode matcher;
+    @Child @Executed JavaScriptNode subject;
+    @Child @Executed JavaScriptNode receiver;
+
+    private final boolean isStrict;
+
+    protected InvokeCustomMatcherOrThrowNode(JSContext context, JavaScriptNode matcher, JavaScriptNode subject, JavaScriptNode receiver, boolean isStrict) {
+        this.getCustomMatcherNode = GetMethodNode.create(context, Symbol.SYMBOL_CUSTOM_MATCHER);
+        this.callNode = JSFunctionCallNode.createCall();
+
+        this.matcher = matcher;
+        this.subject = subject;
+        this.receiver = receiver;
+
+        this.isStrict = isStrict;
+    }
+
+    public static InvokeCustomMatcherOrThrowNode create(JSContext context, JavaScriptNode matcher, JavaScriptNode subject, JavaScriptNode receiver, boolean isStrict) {
+        return InvokeCustomMatcherOrThrowNodeGen.create(context, matcher, subject, receiver, isStrict);
+    }
+
+    public abstract IteratorRecord execute(Object matcher, Object subject, Object receiver);
+
+    @Specialization
+    protected final IteratorRecord invokeCustomMatcherOrThrow(Object matcher, Object subject, Object receiver,
+                                                              @Cached InlinedBranchProfile errorBranchProfile,
+                                                              @Cached IsObjectNode isObjectNode,
+                                                              @Cached GetIteratorNode getIteratorNode) {
+        // 1. If matcher is not an Object, throw a TypeError exception.
+        if (!isObjectNode.executeBoolean(matcher)) {
+            errorBranchProfile.enter(this);
+            throw Errors.createTypeErrorNotAnObject(matcher);
+        }
+
+        // 2. Let f be ? GetMethod(matcher, @@customMatcher).
+        final var f = this.getCustomMatcherNode.executeWithTarget(matcher);
+
+        // 3. If f is undefined, throw a TypeError exception.
+        if (f == Undefined.instance) {
+            errorBranchProfile.enter(this);
+
+            if (this.isStrict) {
+                throw Errors.createTypeError("matcher does not have Symbol.customMatcher method");
+            } else {
+                // this is non-spec behavior, for context see https://github.com/tc39/proposal-extractors/issues/34
+                // attempt to call the matcher as a function to ensure side effects are preserved for backwards compatibility
+                this.callNode.executeCall(JSArguments.create(matcher, matcher, subject, "list", receiver));
+                throw Errors.createReferenceError("cannot assign to function call");
+            }
+        }
+
+        // 4. Let result be ? Call(f, matcher, « subject, "list", receiver »).
+        final var result = this.callNode.executeCall(JSArguments.create(matcher, f, subject, "list", receiver));
+
+        // 5. If result is not an Object, throw a TypeError exception.
+        if (!isObjectNode.executeBoolean(result)) {
+            errorBranchProfile.enter(this);
+            throw Errors.createTypeErrorInvalidCustomMatcherReturnValue(result, this);
+        }
+
+        // 6. Let iteratorRecord be ? GetIterator(result, sync). & 7. Return iteratorRecord.
+        return getIteratorNode.execute(this, result);
+    }
+}
diff --git a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/Errors.java b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/Errors.java
index 4d924e7b7ea..99b6d780bc6 100644
--- a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/Errors.java
+++ b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/Errors.java
@@ -1053,4 +1053,9 @@ public static JSException createTypeErrorWrongDecoratorReturn(Node originatingNo
     public static JSException createRangeErrorEncodingNotSupported(TruffleString encoding) {
         return Errors.createRangeError("Unsupported encoding: " + encoding);
     }
+
+    @TruffleBoundary
+    public static JSException createTypeErrorInvalidCustomMatcherReturnValue(Object value, Node originatingNode) {
+        return Errors.createTypeError("[Symbol.customMatcher] must return an object, got: " + JSRuntime.safeToString(value), originatingNode);
+    }
 }
diff --git a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSContextOptions.java b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSContextOptions.java
index 2a2cb00239f..1a90180f1b4 100644
--- a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSContextOptions.java
+++ b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSContextOptions.java
@@ -733,6 +733,11 @@ public String apply(String name) {
     public static final OptionKey<Boolean> TEXT_ENCODING = new OptionKey<>(false);
     @CompilationFinal private boolean textEncoding;
 
+    public static final String EXTRACTORS_NAME = JS_OPTION_PREFIX + "extractors";
+    @Option(name = EXTRACTORS_NAME, category = OptionCategory.USER, stability = OptionStability.EXPERIMENTAL, help = "Support for Extractors proposal")
+    public static final OptionKey<Boolean> EXTRACTORS = new OptionKey<>(false);
+    @CompilationFinal private boolean extractors;
+
     private static OptionType<Integer> integerRange(int min, int max) {
         return new OptionType<>("Integer", sv -> {
             try {
@@ -847,6 +852,7 @@ private void cacheOptions(SandboxPolicy sandboxPolicy) {
         this.stackTraceAPI = STACK_TRACE_API.hasBeenSet(optionValues) ? readBooleanOption(STACK_TRACE_API) : (v8CompatibilityMode || nashornCompatibilityMode);
         this.worker = WORKER.hasBeenSet(optionValues) ? readBooleanOption(WORKER) : testV8Mode;
         this.textEncoding = readBooleanOption(TEXT_ENCODING);
+        this.extractors = readBooleanOption(EXTRACTORS);
     }
 
     private UnhandledRejectionsTrackingMode readUnhandledRejectionsMode() {
@@ -1354,4 +1360,8 @@ public boolean isWorker() {
         return worker;
     }
 
+    public boolean isExtractors() {
+        return extractors;
+    }
+
 }
diff --git a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSLanguageOptions.java b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSLanguageOptions.java
index a19f06b8023..1bb5eae8ae4 100644
--- a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSLanguageOptions.java
+++ b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSLanguageOptions.java
@@ -132,6 +132,7 @@ public record JSLanguageOptions(
                 boolean arrayElementsAmongMembers,
                 boolean stackTraceAPI,
                 boolean worker,
+                boolean extractors,
                 String locale) {
 
     public static JSLanguageOptions fromOptionValues(SandboxPolicy sandboxPolicy, OptionValues optionValues) {
@@ -217,6 +218,7 @@ public static JSLanguageOptions fromContextOptions(JSContextOptions options) {
         boolean arrayElementsAmongMembers = options.isArrayElementsAmongMembers();
         boolean stackTraceAPI = options.isStackTraceAPI();
         boolean worker = options.isWorker();
+        boolean extractors = options.isExtractors();
         String locale = options.getLocale();
 
         return new JSLanguageOptions(
@@ -297,6 +299,7 @@ public static JSLanguageOptions fromContextOptions(JSContextOptions options) {
                         arrayElementsAmongMembers,
                         stackTraceAPI,
                         worker,
+                        extractors,
                         locale);
     }
 
diff --git a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSParserOptions.java b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSParserOptions.java
index 0b80cddce38..fa1519753fc 100644
--- a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSParserOptions.java
+++ b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSParserOptions.java
@@ -63,7 +63,8 @@ public record JSParserOptions(boolean strict,
                 boolean sourcePhaseImports,
                 boolean privateFieldsIn,
                 boolean topLevelAwait,
-                boolean v8Intrinsics) {
+                boolean v8Intrinsics,
+                boolean extractors) {
 
     public static JSParserOptions fromLanguageOptions(JSLanguageOptions options) {
         int ecmaScriptVersion = options.ecmaScriptVersion();
@@ -83,14 +84,15 @@ public static JSParserOptions fromLanguageOptions(JSLanguageOptions options) {
         boolean privateFieldsIn = options.privateFieldsIn();
         boolean topLevelAwait = options.topLevelAwait();
         boolean v8Intrinsics = options.v8Intrinsics();
+        boolean extractors = options.extractors();
         return new JSParserOptions(strict, scripting, shebang, ecmaScriptVersion, syntaxExtensions, constAsVar, functionStatementError, emptyStatements, annexB, allowBigInt,
-                        classFields, importAttributes, importAssertions, sourcePhaseImports, privateFieldsIn, topLevelAwait, v8Intrinsics);
+                        classFields, importAttributes, importAssertions, sourcePhaseImports, privateFieldsIn, topLevelAwait, v8Intrinsics, extractors);
     }
 
     public JSParserOptions withStrict(@SuppressWarnings("hiding") boolean strict) {
         if (strict != this.strict) {
             return new JSParserOptions(strict, scripting, shebang, ecmaScriptVersion, syntaxExtensions, constAsVar, functionStatementError, emptyStatements, annexB, allowBigInt,
-                            classFields, importAttributes, importAssertions, sourcePhaseImports, privateFieldsIn, topLevelAwait, v8Intrinsics);
+                            classFields, importAttributes, importAssertions, sourcePhaseImports, privateFieldsIn, topLevelAwait, v8Intrinsics, extractors);
         }
         return this;
     }
diff --git a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSRealm.java b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSRealm.java
index f9b3fdef5fb..ea79fd364fb 100644
--- a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSRealm.java
+++ b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/JSRealm.java
@@ -2340,6 +2340,7 @@ private static void setupPredefinedSymbols(JSDynamicObject symbolFunction) {
         putSymbolProperty(symbolFunction, Strings.TO_STRING_TAG, Symbol.SYMBOL_TO_STRING_TAG);
         putSymbolProperty(symbolFunction, Strings.TO_PRIMITIVE, Symbol.SYMBOL_TO_PRIMITIVE);
         putSymbolProperty(symbolFunction, Strings.UNSCOPABLES, Symbol.SYMBOL_UNSCOPABLES);
+        putSymbolProperty(symbolFunction, Strings.CUSTOM_MATCHER, Symbol.SYMBOL_CUSTOM_MATCHER);
     }
 
     private static void putSymbolProperty(JSDynamicObject symbolFunction, TruffleString name, Symbol symbol) {
diff --git a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/Strings.java b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/Strings.java
index ef98937bd58..71c61c893b2 100644
--- a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/Strings.java
+++ b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/Strings.java
@@ -263,6 +263,7 @@ private Strings() {
     public static final TruffleString TO_SORTED = constant("toSorted");
     public static final TruffleString TO_SPLICED = constant("toSpliced");
     public static final TruffleString TO_TEMPORAL_INSTANT = constant("toTemporalInstant");
+    public static final TruffleString CUSTOM_MATCHER = constant("customMatcher");
 
     public static final TruffleString UC_ARRAY = constant("Array");
     public static final TruffleString UC_OBJECT = constant("Object");
diff --git a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/Symbol.java b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/Symbol.java
index 4da225c8d02..786b2d659bb 100644
--- a/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/Symbol.java
+++ b/graal-js/src/com.oracle.truffle.js/src/com/oracle/truffle/js/runtime/Symbol.java
@@ -130,6 +130,11 @@ public final class Symbol implements TruffleObject {
      * excluded from the with environment bindings of the associated object.
      */
     public static final Symbol SYMBOL_UNSCOPABLES = Symbol.createWellKnown(Strings.constant("Symbol.unscopables"));
+    /**
+     * When destructuring using the Extractor pattern, the result of this function will be destructured.
+     * Only relevant if the option {@code truffle.js.parser.extractors} is enabled.
+     */
+    public static final Symbol SYMBOL_CUSTOM_MATCHER = Symbol.createWellKnown(Strings.constant("Symbol.customMatcher"));
 
     /**
      * [[Description]] of Symbol if it is a String value, {@code null} otherwise ([[Description]] is