@openrewrite/rewrite 8.67.0-20251119-160338 → 8.67.0-20251119-202228

package/dist/javascript/templating/types.d.ts

@@ -16,10 +16,45 @@ export interface VariadicOptions {
      */
     max?: number;
 }
+/**
+ * Read-only access to captures matched so far during pattern matching.
+ * Provides a consistent interface with MatchResult for looking up captured values.
+ */
+export interface CaptureMap {
+    /**
+     * Gets the value of a capture by Capture object or name.
+     * Returns undefined if the capture hasn't been matched yet.
+     */
+    get<T>(capture: Capture<T>): T | undefined;
+    get(capture: string): any;
+    /**
+     * Checks if a capture has been matched.
+     */
+    has(capture: Capture | string): boolean;
+}
+/**
+ * Context passed to capture constraint functions.
+ * Provides access to the cursor for AST navigation and previously matched captures.
+ */
+export interface CaptureConstraintContext {
+    /**
+     * The cursor pointing to the node being matched.
+     * Allows navigating the AST (parent, root, etc.).
+     */
+    cursor: Cursor;
+    /**
+     * Read-only view of values captured so far in the matching process.
+     * Allows constraints to depend on previous captures.
+     * Returns undefined for captures that haven't been processed yet.
+     */
+    captures: CaptureMap;
+}
 /**
  * Constraint function for captures.
- * The cursor parameter is always provided with a defined value, but functions can
- * choose to accept it or not (TypeScript allows functions with fewer parameters).
+ *
+ * Receives the node being validated and a context providing access to:
+ * - cursor: For navigating the AST
+ * - captures: For accessing previously matched captures
  *
  * For non-variadic captures: use ConstraintFunction<T> where T is the node type
  * For variadic captures: use ConstraintFunction<T[]> where T[] is the array type
@@ -27,7 +62,7 @@ export interface VariadicOptions {
  * When used with variadic captures, the cursor points to the nearest common parent
  * of the captured elements.
  */
-export type ConstraintFunction<T> = (node: T, cursor: Cursor) => boolean;
+export type ConstraintFunction<T> = (node: T, context: CaptureConstraintContext) => boolean;
 /**
  * Options for the capture function.
  *
@@ -36,39 +71,45 @@ export type ConstraintFunction<T> = (node: T, cursor: Cursor) => boolean;
  * - For regular captures: constraint receives a single node of type T
  * - For variadic captures: constraint receives an array of nodes of type T[]
  *
- * The constraint function can optionally receive a cursor parameter to perform
- * context-aware validation during pattern matching.
+ * The context parameter provides access to the cursor and previously matched captures.
  */
 export interface CaptureOptions<T = any> {
     name?: string;
     variadic?: boolean | VariadicOptions;
     /**
      * Optional constraint function that validates whether a captured node should be accepted.
-     * The function always receives:
+     * The function receives:
      * - node: The captured node (or array of nodes for variadic captures)
-     * - cursor: A cursor at the captured node's position (always defined)
-     *
-     * Functions can choose to accept just the node parameter if they don't need the cursor.
+     * - context: Provides access to cursor and previously matched captures
      *
      * @param node The captured node to validate
-     * @param cursor Cursor at the captured node's position
+     * @param context Provides cursor for AST navigation and previously matched captures
      * @returns true if the capture should be accepted, false otherwise
      *
      * @example
      * ```typescript
-     * // Simple node validation (cursor parameter ignored)
+     * // Simple node validation
      * capture<J.Literal>('size', {
      *     constraint: (node) => typeof node.value === 'number' && node.value > 100
      * })
      *
-     * // Context-aware validation (using cursor)
+     * // Context-aware validation using cursor
      * capture<J.MethodInvocation>('method', {
-     *     constraint: (node, cursor) => {
+     *     constraint: (node, context) => {
      *         if (!node.name.simpleName.startsWith('get')) return false;
-     *         const cls = cursor.firstEnclosing(isClassDeclaration);
+     *         const cls = context.cursor.firstEnclosing(isClassDeclaration);
      *         return cls?.name.simpleName === 'ApiController';
      *     }
      * })
+     *
+     * // Validation depending on previous captures
+     * const min = capture('min');
+     * const max = capture('max', {
+     *     constraint: (node, context) => {
+     *         const minVal = context.captures.get(min);
+     *         return minVal && node.value > minVal.value;
+     *     }
+     * })
      * ```
      */
     constraint?: ConstraintFunction<T>;
@@ -77,9 +118,37 @@ export interface CaptureOptions<T = any> {
      * a preamble declaring the capture identifier with this type annotation, allowing
      * the TypeScript parser/compiler to produce a properly type-attributed AST.
      *
+     * **Why Use Type Attribution:**
+     * When matching against TypeScript code with type information, providing a type ensures
+     * the pattern's AST has matching type attribution, which can be important for:
+     * - Semantic matching based on types
+     * - Matching code that depends on type inference
+     * - Ensuring pattern parses with correct type context
+     *
      * Can be specified as:
-     * - A string type annotation (e.g., "boolean", "string", "number")
+     * - A string type annotation (e.g., "boolean", "string", "number", "Promise<any>", "User[]")
      * - A Type instance from the AST (the type will be inferred from the Type)
+     *
+     * @example
+     * ```typescript
+     * // Match promise chains with proper type attribution
+     * const chain = capture({
+     *   name: 'chain',
+     *   type: 'Promise<any>',  // TypeScript will attribute this as Promise type
+     *   constraint: (call: J.MethodInvocation) => {
+     *     // Validate promise chain structure
+     *     return call.name.simpleName === 'then';
+     *   }
+     * });
+     * pattern`${chain}.catch(err => console.log(err))`
+     *
+     * // Match arrays with type annotation
+     * const items = capture({
+     *   name: 'items',
+     *   type: 'number[]',  // Array of numbers
+     * });
+     * pattern`${items}.map(x => x * 2)`
+     * ```
      */
     type?: string | Type;
 }
@@ -360,6 +429,33 @@ export interface TemplateOptions {
      */
     dependencies?: Record<string, string>;
 }
+/**
+ * Options for template application.
+ */
+export interface ApplyOptions {
+    /**
+     * Values for parameters in the template.
+     * Can be a Map, MatchResult, or plain object with capture names as keys.
+     *
+     * @example
+     * ```typescript
+     * // Using MatchResult from pattern matching
+     * const match = await pattern.match(node, cursor);
+     * await template.apply(node, cursor, { values: match });
+     *
+     * // Using a Map
+     * await template.apply(node, cursor, {
+     *     values: new Map([['x', someNode]])
+     * });
+     *
+     * // Using a plain object
+     * await template.apply(node, cursor, {
+     *     values: { x: someNode }
+     * });
+     * ```
+     */
+    values?: Map<Capture | string, J> | MatchResult | Record<string, J>;
+}
 /**
  * Represents a replacement rule that can match a pattern and apply a template.
  */

package/dist/javascript/templating/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/javascript/templating/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/javascript/templating/types.ts"],"names":[],"mappings":"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"}

package/dist/version.txt

@@ -1 +1 @@
-8.67.0-20251119-160338
+8.67.0-20251119-202228

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrewrite/rewrite",
-  "version": "8.67.0-20251119-160338",
+  "version": "8.67.0-20251119-202228",
   "license": "Moderne Source Available License",
   "description": "OpenRewrite JavaScript.",
   "homepage": "https://github.com/openrewrite/rewrite",

package/src/javascript/templating/capture.ts

@@ -15,7 +15,7 @@
  */
 import {Cursor} from '../..';
 import {J, Type} from '../../java';
-import {Any, Capture, CaptureOptions, ConstraintFunction, TemplateParam, VariadicOptions} from './types';
+import {Any, Capture, CaptureConstraintContext, CaptureOptions, ConstraintFunction, TemplateParam, VariadicOptions} from './types';
 
 /**
  * Combines multiple constraints with AND logic.
@@ -30,8 +30,8 @@ import {Any, Capture, CaptureOptions, ConstraintFunction, TemplateParam, Variadi
  *     )
  * });
  */
-export function and<T>(...constraints: ((node: T, cursor?: Cursor) => boolean)[]): (node: T, cursor?: Cursor) => boolean {
-    return (node: T, cursor?: Cursor) => constraints.every(c => c(node, cursor));
+export function and<T>(...constraints: ConstraintFunction<T>[]): ConstraintFunction<T> {
+    return (node: T, context: CaptureConstraintContext) => constraints.every(c => c(node, context));
 }
 
 /**
@@ -46,8 +46,8 @@ export function and<T>(...constraints: ((node: T, cursor?: Cursor) => boolean)[]
  *     )
  * });
  */
-export function or<T>(...constraints: ((node: T, cursor?: Cursor) => boolean)[]): (node: T, cursor?: Cursor) => boolean {
-    return (node: T, cursor?: Cursor) => constraints.some(c => c(node, cursor));
+export function or<T>(...constraints: ConstraintFunction<T>[]): ConstraintFunction<T> {
+    return (node: T, context: CaptureConstraintContext) => constraints.some(c => c(node, context));
 }
 
 /**
@@ -59,8 +59,8 @@ export function or<T>(...constraints: ((node: T, cursor?: Cursor) => boolean)[])
  *     constraint: not((node) => typeof node.value === 'string')
  * });
  */
-export function not<T>(constraint: (node: T, cursor?: Cursor) => boolean): (node: T, cursor?: Cursor) => boolean {
-    return (node: T, cursor?: Cursor) => !constraint(node, cursor);
+export function not<T>(constraint: ConstraintFunction<T>): ConstraintFunction<T> {
+    return (node: T, context: CaptureConstraintContext) => !constraint(node, context);
 }
 
 // Symbol to access the internal capture name without triggering Proxy

package/src/javascript/templating/comparator.ts

@@ -18,7 +18,8 @@ import {J} from '../../java';
 import {JS} from '../index';
 import {JavaScriptSemanticComparatorVisitor} from '../comparator';
 import {CaptureMarker, CaptureStorageValue, PlaceholderUtils} from './utils';
-import {DebugLogEntry, MatchExplanation} from './types';
+import {Capture, CaptureConstraintContext, CaptureMap, DebugLogEntry, MatchExplanation} from './types';
+import {CAPTURE_NAME_SYMBOL} from './capture';
 
 /**
  * Debug callbacks for pattern matching.
@@ -62,6 +63,28 @@ export interface MatcherCallbacks {
     debug?: DebugCallbacks;
 }
 
+/**
+ * Implementation of CaptureMap that wraps the capture storage.
+ * Provides read-only access to previously matched captures.
+ */
+class CaptureMapImpl implements CaptureMap {
+    constructor(private readonly storage: Map<string, CaptureStorageValue>) {}
+
+    get<T>(capture: Capture<T>): T | undefined;
+    get(capture: string): any;
+    get(capture: Capture | string): any {
+        // Use symbol to get internal name without triggering Proxy
+        const name = typeof capture === 'string' ? capture : ((capture as any)[CAPTURE_NAME_SYMBOL] || capture.getName());
+        return this.storage.get(name);
+    }
+
+    has(capture: Capture | string): boolean {
+        // Use symbol to get internal name without triggering Proxy
+        const name = typeof capture === 'string' ? capture : ((capture as any)[CAPTURE_NAME_SYMBOL] || capture.getName());
+        return this.storage.has(name);
+    }
+}
+
 /**
  * A comparator for pattern matching that is lenient about optional properties.
  * Allows patterns without type annotations to match actual code with type annotations.
@@ -76,6 +99,19 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
         super(lenientTypeMatching);
     }
 
+    /**
+     * Builds the constraint context with the cursor and current captures.
+     * @param cursor The cursor to include in the context
+     * @returns The constraint context for evaluating capture constraints
+     */
+    protected buildConstraintContext(cursor: Cursor): CaptureConstraintContext {
+        const state = this.matcher.saveState();
+        return {
+            cursor,
+            captures: new CaptureMapImpl(state.storage)
+        };
+    }
+
     override async visit<R extends J>(j: Tree, p: J, parent?: Cursor): Promise<R | undefined> {
         // Check if the pattern node is a capture - this handles unwrapped captures
         // (Wrapped captures in J.RightPadded are handled by visitRightPadded override)
@@ -91,12 +127,15 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
                 : new Cursor(p);
             this.targetCursor = cursorAtCapturedNode;
             try {
-                // Evaluate constraint with cursor at the captured node (always defined)
+                // Evaluate constraint with context (cursor + previous captures)
                 // Skip constraint for variadic captures - they're evaluated in matchSequence with the full array
-                if (captureMarker.constraint && !captureMarker.variadicOptions && !captureMarker.constraint(p, cursorAtCapturedNode)) {
-                    const captureName = captureMarker.captureName || 'unnamed';
-                    const targetKind = (p as any).kind || 'unknown';
-                    return this.constraintFailed(captureName, targetKind) as R;
+                if (captureMarker.constraint && !captureMarker.variadicOptions) {
+                    const context = this.buildConstraintContext(cursorAtCapturedNode);
+                    if (!captureMarker.constraint(p, context)) {
+                        const captureName = captureMarker.captureName || 'unnamed';
+                        const targetKind = (p as any).kind || 'unknown';
+                        return this.constraintFailed(captureName, targetKind) as R;
+                    }
                 }
 
                 const success = this.matcher.handleCapture(captureMarker, p, undefined);
@@ -164,7 +203,7 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
             try {
                 // Evaluate constraint with cursor at the captured node (always defined)
                 // Skip constraint for variadic captures - they're evaluated in matchSequence with the full array
-                if (captureMarker.constraint && !captureMarker.variadicOptions && !captureMarker.constraint(targetElement as J, cursorAtCapturedNode)) {
+                if (captureMarker.constraint && !captureMarker.variadicOptions && !captureMarker.constraint(targetElement as J, this.buildConstraintContext(cursorAtCapturedNode))) {
                     const captureName = captureMarker.captureName || 'unnamed';
                     const targetKind = (targetElement as any).kind || 'unknown';
                     return this.constraintFailed(captureName, targetKind);
@@ -604,7 +643,7 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
                 // The targetCursor points to the parent container (always defined in container matching)
                 if (captureMarker.constraint) {
                     const cursor = this.targetCursor || new Cursor(targetElements[0]);
-                    if (!captureMarker.constraint(capturedElements as any, cursor)) {
+                    if (!captureMarker.constraint(capturedElements as any, this.buildConstraintContext(cursor))) {
                         continue; // Try next consumption amount
                     }
                 }
@@ -868,7 +907,7 @@ export class DebugPatternMatchingComparator extends PatternMatchingComparator {
             try {
                 if (captureMarker.constraint && !captureMarker.variadicOptions) {
                     this.debug.log('debug', 'constraint', `Evaluating constraint for capture: ${captureMarker.captureName}`);
-                    const constraintResult = captureMarker.constraint(p, cursorAtCapturedNode);
+                    const constraintResult = captureMarker.constraint(p, this.buildConstraintContext(cursorAtCapturedNode));
                     if (!constraintResult) {
                         this.debug.log('info', 'constraint', `Constraint failed for capture: ${captureMarker.captureName}`);
                         this.debug.setExplanation('constraint-failed', `Capture ${captureMarker.captureName} with valid constraint`, `Constraint failed for ${(p as any).kind}`, `Constraint evaluation returned false`);
@@ -965,7 +1004,7 @@ export class DebugPatternMatchingComparator extends PatternMatchingComparator {
             try {
                 if (captureMarker.constraint && !captureMarker.variadicOptions) {
                     this.debug.log('debug', 'constraint', `Evaluating constraint for wrapped capture: ${captureMarker.captureName}`);
-                    const constraintResult = captureMarker.constraint(targetElement as J, cursorAtCapturedNode);
+                    const constraintResult = captureMarker.constraint(targetElement as J, this.buildConstraintContext(cursorAtCapturedNode));
                     if (!constraintResult) {
                         this.debug.log('info', 'constraint', `Constraint failed for wrapped capture: ${captureMarker.captureName}`);
                         this.debug.setExplanation('constraint-failed', `Capture ${captureMarker.captureName} with valid constraint`, `Constraint failed for ${(targetElement as any).kind}`, `Constraint evaluation returned false`);
@@ -1316,7 +1355,7 @@ export class DebugPatternMatchingComparator extends PatternMatchingComparator {
                 if (captureMarker.constraint) {
                     this.debug.log('debug', 'constraint', `Evaluating variadic constraint for capture: ${captureMarker.captureName} (${capturedElements.length} elements)`);
                     const cursor = this.targetCursor || new Cursor(targetElements[0]);
-                    const constraintResult = captureMarker.constraint(capturedElements as any, cursor);
+                    const constraintResult = captureMarker.constraint(capturedElements as any, this.buildConstraintContext(cursor));
                     if (!constraintResult) {
                         this.debug.log('info', 'constraint', `Variadic constraint failed for capture: ${captureMarker.captureName}`);
                         continue;

package/src/javascript/templating/pattern.ts

@@ -15,7 +15,17 @@
  */
 import {Cursor} from '../..';
 import {J} from '../../java';
-import {Any, Capture, DebugLogEntry, DebugOptions, MatchAttemptResult, MatchExplanation, MatchOptions, PatternOptions, MatchResult as IMatchResult} from './types';
+import {
+    Any,
+    Capture,
+    DebugLogEntry,
+    DebugOptions,
+    MatchAttemptResult,
+    MatchExplanation,
+    MatchOptions,
+    MatchResult as IMatchResult,
+    PatternOptions
+} from './types';
 import {CAPTURE_CAPTURING_SYMBOL, CAPTURE_NAME_SYMBOL, CaptureImpl, RAW_CODE_SYMBOL, RawCode} from './capture';
 import {DebugPatternMatchingComparator, MatcherCallbacks, MatcherState, PatternMatchingComparator} from './comparator';
 import {CaptureMarker, CaptureStorageValue, generateCacheKey, globalAstCache, WRAPPERS_MAP_SYMBOL} from './utils';
@@ -190,7 +200,7 @@ export class Pattern {
      *     })
      */
     configure(options: PatternOptions): Pattern {
-        this._options = {...this._options, ...options};
+        this._options = { ...this._options, ...options };
         // Invalidate cache when configuration changes
         this._cachedAstPattern = undefined;
         return this;
@@ -252,23 +262,22 @@ export class Pattern {
     /**
      * Creates a matcher for this pattern against a specific AST node.
      *
-     * @param ast The AST node to match against
-     * @param cursor Optional cursor at the node's position in a larger tree. Used for context-aware
-     *               capture constraints to navigate to parent nodes. If omitted, a cursor will be
-     *               created at the ast root, allowing constraints to navigate within the matched subtree.
+     * @param tree The AST node to match against
+     * @param cursor Cursor at the node's position in a larger tree. Used for context-aware
+     *               capture constraints to navigate to parent nodes.
      * @param options Optional match options (e.g., debug flag)
      * @returns A MatchResult if the pattern matches, undefined otherwise
      *
      * @example
      * ```typescript
      * // Normal match
-     * const match = await pattern.match(node);
+     * const match = await pattern.match(node, cursor);
      *
      * // Debug this specific call
      * const match = await pattern.match(node, cursor, { debug: true });
      * ```
      */
-    async match(ast: J, cursor?: Cursor, options?: MatchOptions): Promise<MatchResult | undefined> {
+    async match(tree: J, cursor: Cursor, options?: MatchOptions): Promise<MatchResult | undefined> {
         // Three-level precedence: call > pattern > global
         const debugEnabled =
             options?.debug !== undefined
@@ -279,8 +288,8 @@ export class Pattern {
 
         if (debugEnabled) {
             // Use matchWithExplanation and log the result
-            const result = await this.matchWithExplanation(ast, cursor);
-            await this.logMatchResult(ast, cursor, result);
+            const result = await this.matchWithExplanation(tree, cursor);
+            await this.logMatchResult(tree, cursor, result);
 
             if (result.matched) {
                 // result.result is the MatchResult class instance
@@ -291,7 +300,7 @@ export class Pattern {
         }
 
         // Fast path - no debug
-        const matcher = new Matcher(this, ast, cursor);
+        const matcher = new Matcher(this, tree, cursor);
         const success = await matcher.matches();
         if (!success) {
             return undefined;
@@ -305,10 +314,10 @@ export class Pattern {
      * Formats and logs the match result to stderr.
      * @private
      */
-    private async logMatchResult(ast: J, cursor: Cursor | undefined, result: MatchAttemptResult): Promise<void> {
+    private async logMatchResult(tree: J, cursor: Cursor | undefined, result: MatchAttemptResult): Promise<void> {
         const patternSource = this.getPatternSource();
         const patternId = `Pattern #${this.patternId}`;
-        const nodeKind = (ast as any).kind || 'unknown';
+        const nodeKind = (tree as any).kind || 'unknown';
         // Format kind: extract short name (e.g., "org.openrewrite.java.tree.J$Binary" -> "J$Binary")
         const shortKind = typeof nodeKind === 'string'
             ? nodeKind.split('.').pop() || nodeKind
@@ -324,7 +333,7 @@ export class Pattern {
         let treeStr: string;
         try {
             const printer = TreePrinters.printer(JS.Kind.CompilationUnit);
-            treeStr = await printer.print(ast);
+            treeStr = await printer.print(tree);
         } catch (e) {
             treeStr = '(tree printing unavailable)';
         }
@@ -508,15 +517,15 @@ export class Pattern {
      * - Explanation of failure (if not matched)
      * - Debug log entries showing the matching process
      *
-     * @param ast The AST node to match against
-     * @param cursor Optional cursor at the node's position in a larger tree
+     * @param tree The AST node to match against
+     * @param cursor Cursor at the node's position in a larger tree
      * @param debugOptions Optional debug options (defaults to all logging enabled)
      * @returns Detailed result with debug information
      *
      * @example
      * const x = capture('x');
      * const pat = pattern`console.log(${x})`;
-     * const attempt = await pat.matchWithExplanation(node);
+     * const attempt = await pat.matchWithExplanation(node, cursor);
      * if (attempt.matched) {
      *     console.log('Matched!');
      *     console.log('Captured x:', attempt.result.get('x'));
@@ -526,8 +535,8 @@ export class Pattern {
      * }
      */
     async matchWithExplanation(
-        ast: J,
-        cursor?: Cursor,
+        tree: J,
+        cursor: Cursor,
         debugOptions?: DebugOptions
     ): Promise<MatchAttemptResult> {
         // Default to full debug logging if not specified
@@ -538,7 +547,7 @@ export class Pattern {
             ...debugOptions
         };
 
-        const matcher = new Matcher(this, ast, cursor, options);
+        const matcher = new Matcher(this, tree, cursor, options);
         const success = await matcher.matches();
 
         if (success) {
@@ -671,17 +680,16 @@ class Matcher {
      *
      * @param pattern The pattern to match
      * @param ast The AST node to match against
-     * @param cursor Optional cursor at the AST node's position
+     * @param cursor Cursor at the AST node's position
      * @param debugOptions Optional debug options for instrumentation
      */
     constructor(
         private readonly pattern: Pattern,
         private readonly ast: J,
-        cursor?: Cursor,
+        cursor: Cursor,
         debugOptions?: DebugOptions
     ) {
-        // If no cursor provided, create one at the ast root so constraints can navigate up
-        this.cursor = cursor ?? new Cursor(ast, undefined);
+        this.cursor = cursor;
         this.debugOptions = debugOptions ?? {};
     }
 

package/src/javascript/templating/rewrite.ts

@@ -57,10 +57,10 @@ class RewriteRuleImpl implements RewriteRule {
                 if (typeof this.after === 'function') {
                     // Call the function to get a template, then apply it
                     const template = this.after(match);
-                    result = await template.apply(cursor, node, match);
+                    result = await template.apply(node, cursor, { values: match });
                 } else {
                     // Use template.apply() as before
-                    result = await this.after.apply(cursor, node, match);
+                    result = await this.after.apply(node, cursor, { values: match });
                 }
 
                 if (result) {

package/src/javascript/templating/template.ts

@@ -15,7 +15,7 @@
  */
 import {Cursor, Tree} from '../..';
 import {J} from '../../java';
-import {Capture, Parameter, TemplateOptions, TemplateParameter} from './types';
+import {ApplyOptions, Parameter, TemplateOptions, TemplateParameter} from './types';
 import {MatchResult} from './pattern';
 import {generateCacheKey, globalAstCache, WRAPPERS_MAP_SYMBOL} from './utils';
 import {CAPTURE_NAME_SYMBOL, RAW_CODE_SYMBOL} from './capture';
@@ -174,6 +174,18 @@ export class Template {
     private options: TemplateOptions = {};
     private _cachedTemplate?: J;
 
+    /**
+     * Creates a new template.
+     *
+     * @param templateParts The string parts of the template
+     * @param parameters The parameters between the string parts
+     */
+    constructor(
+        private readonly templateParts: TemplateStringsArray,
+        private readonly parameters: Parameter[]
+    ) {
+    }
+
     /**
      * Creates a new builder for constructing templates programmatically.
      *
@@ -191,18 +203,6 @@ export class Template {
         return new TemplateBuilder();
     }
 
-    /**
-     * Creates a new template.
-     *
-     * @param templateParts The string parts of the template
-     * @param parameters The parameters between the string parts
-     */
-    constructor(
-        private readonly templateParts: TemplateStringsArray,
-        private readonly parameters: Parameter[]
-    ) {
-    }
-
     /**
      * Configures this template with additional options.
      *
@@ -217,7 +217,7 @@ export class Template {
      *     })
      */
     configure(options: TemplateOptions): Template {
-        this.options = { ...this.options, ...options };
+        this.options = {...this.options, ...options};
         // Invalidate cache when configuration changes
         this._cachedTemplate = undefined;
         return this;
@@ -236,7 +236,7 @@ export class Template {
      * @returns The cached or newly computed template tree
      * @internal
      */
-    async getTemplateTree(): Promise<JS.CompilationUnit> {
+    private async getTemplateTree(): Promise<JS.CompilationUnit> {
         // Level 1: Instance cache (fastest path)
         if (this._cachedTemplate) {
             return this._cachedTemplate as JS.CompilationUnit;
@@ -286,12 +286,30 @@ export class Template {
     /**
      * Applies this template and returns the resulting tree.
      *
+     * @param tree Input tree to transform
      * @param cursor The cursor pointing to the current location in the AST
-     * @param tree Input tree
-     * @param values values for parameters in template
+     * @param options Optional configuration including values for parameters
      * @returns A Promise resolving to the generated AST node
+     *
+     * @example
+     * ```typescript
+     * // Simple application without values
+     * const result = await tmpl.apply(node, cursor);
+     *
+     * // With values from pattern match
+     * const match = await pat.match(node, cursor);
+     * const result = await tmpl.apply(node, cursor, { values: match });
+     *
+     * // With explicit values
+     * const result = await tmpl.apply(node, cursor, {
+     *     values: { x: someNode, y: anotherNode }
+     * });
+     * ```
      */
-    async apply(cursor: Cursor, tree: J, values?: Map<Capture | string, J> | Pick<Map<string, J>, 'get'> | Record<string, J>): Promise<J | undefined> {
+    async apply(tree: J, cursor: Cursor, options?: ApplyOptions): Promise<J | undefined> {
+        // Extract values from options
+        const values = options?.values;
+
         // Normalize the values map: convert any Capture keys to string keys
         let normalizedValues: Pick<Map<string, J>, 'get'> | undefined;
         let wrappersMap: Map<string, J.RightPadded<J> | J.RightPadded<J>[]> = new Map();