assign-gingerly 0.0.78 → 0.0.80

package/assignGingerly.ts

@@ -506,9 +506,10 @@ export function evaluatePathWithMethods(
   value: any,
   withMethods: Set<string>,
   permissionProcessor?: PermissionProcessor
-): { target: any; lastKey: string; isMethod: boolean; isZeroArg: boolean } {
+): { target: any; lastKey: string; isMethod: boolean; isZeroArg: boolean; lastSegmentConsumed: boolean } {
   let current = target;
   let i = 0;
+  let lastSegmentConsumed = false;
   
   // Process all segments except the last one
   while (i < pathParts.length - 1) {
@@ -525,13 +526,17 @@ export function evaluatePathWithMethods(
       const methodName = isZeroArgMethod ? part.slice(0, -1) : part;
       const method = current[methodName];
       if (typeof method === 'function') {
+        const appendArgs = permissionProcessor?.getMethodAppendArgs(methodName) ?? [];
         if (isZeroArgMethod || nextIsMethod) {
           // Zero-arg call - next part is either a method or explicitly not an argument
-          current = method.call(current);
+          current = method.call(current, ...appendArgs);
         } else {
           // Only current is method - call with next part as string arg
-          current = method.call(current, nextPart);
+          current = method.call(current, nextPart, ...appendArgs);
           i++; // Skip next part since we consumed it as argument
+          if (i === pathParts.length - 1) {
+            lastSegmentConsumed = true;
+          }
         }
       } else {
         // Not a function - just access property (create if needed)
@@ -560,7 +565,8 @@ export function evaluatePathWithMethods(
     target: current,
     lastKey,
     isMethod: isAllowedMethod(lastKey, withMethods, permissionProcessor),
-    isZeroArg
+    isZeroArg,
+    lastSegmentConsumed
   };
 }
 
@@ -649,8 +655,9 @@ function applyToEach(
           const methodName = isZeroArgMethod ? part.slice(0, -1) : part;
           const method = current[methodName];
           if (typeof method === 'function') {
+            const appendArgs = permissionProcessor?.getMethodAppendArgs(methodName) ?? [];
             if (isZeroArgMethod) {
-              current = method.call(current);
+              current = method.call(current, ...appendArgs);
               continue;
             }
             // For methods in the middle, we need to check the next part
@@ -659,13 +666,13 @@ function applyToEach(
             const nextIsMethod = nextPart && (withMethods.has(nextPart)
               || (nextPart.endsWith('|') && withMethods.has(nextPart.slice(0, -1))));
             if (nextIsMethod) {
-              current = method.call(current);
+              current = method.call(current, ...appendArgs);
             } else if (nextPart) {
-              current = method.call(current, nextPart);
+              current = method.call(current, nextPart, ...appendArgs);
               // Skip next part
               pathToForEach.splice(nextIndex, 1);
             } else {
-              current = method.call(current);
+              current = method.call(current, ...appendArgs);
             }
           } else {
             current = current[methodName];
@@ -687,13 +694,14 @@ function applyToEach(
         // Last segment is a method - call it
         const method = result.target[result.lastKey];
         if (typeof method === 'function') {
+          const appendArgs = permissionProcessor?.getMethodAppendArgs(result.lastKey) ?? [];
           if (result.isZeroArg) {
-            // Trailing | marker - call with no arguments, ignoring the value
-            method.call(result.target);
+            // Trailing | marker - call with appended args only, ignoring the value
+            method.call(result.target, ...appendArgs);
           } else if (Array.isArray(value)) {
-            method.apply(result.target, value);
+            method.apply(result.target, [...value, ...appendArgs]);
           } else {
-            method.call(result.target, value);
+            method.call(result.target, value, ...appendArgs);
           }
         }
       } else {
@@ -721,6 +729,110 @@ function applyToEach(
   }
 }
 
+/**
+ * Resolve the RHS of a toggle (=!) command to the value that should be negated.
+ * Supports:
+ * - '?.path' nested path strings resolved against target (returns the resolved value, or true if missing)
+ * - plain key strings looked up on target (returns the value, or true if missing)
+ * - resolved literal values (e.g., booleans from assignFrom) returned as-is
+ */
+function resolveValueToNegate(rhsPath: any, target: any): any {
+  if (typeof rhsPath === 'string' && isNestedPath(rhsPath)) {
+    const rhsPathParts = parsePath(rhsPath);
+    let current = target;
+    let exists = true;
+    for (const part of rhsPathParts) {
+      if (current && typeof current === 'object' && part in current) {
+        current = current[part];
+      } else {
+        exists = false;
+        break;
+      }
+    }
+    return exists ? current : true;
+  }
+  if (typeof rhsPath === 'string') {
+    return (rhsPath in target) ? target[rhsPath] : true;
+  }
+  // Non-string resolved value (e.g., boolean, number, null from assignFrom)
+  return rhsPath;
+}
+
+/**
+ * Navigate a path that leads to an iterable, returning the iterable value or undefined.
+ * Handles withMethods and the evaluatePathWithMethods semantics.
+ */
+function getIterableAtPath(
+  target: any,
+  pathParts: string[],
+  value: any,
+  withMethods: Set<string> | undefined,
+  permissionProcessor?: PermissionProcessor
+): any {
+  let current = target;
+  if (pathParts.length > 0) {
+    if (withMethods && withMethods.size > 0) {
+      const result = evaluatePathWithMethods(target, pathParts, value, withMethods, permissionProcessor);
+      // evaluatePathWithMethods returns the container object + last key by default.
+      // If the last segment was consumed as a method argument, or the last segment
+      // is a zero-arg method marked with |, result.target is already the value.
+      if (result.lastSegmentConsumed) {
+        current = result.target;
+      } else if (result.isMethod) {
+        const method = result.target[result.lastKey];
+        if (typeof method === 'function') {
+          const appendArgs = permissionProcessor?.getMethodAppendArgs(result.lastKey) ?? [];
+          current = method.call(result.target, ...appendArgs);
+        } else {
+          current = method;
+        }
+      } else {
+        current = result.target[result.lastKey];
+      }
+    } else {
+      for (const part of pathParts) {
+        current = current[part];
+      }
+    }
+  }
+  return isIterable(current) ? current : undefined;
+}
+
+/**
+ * Apply an operator command (+=, =!, -=, Y=) to each item in an iterable.
+ * Detects @each in the path, navigates to the iterable, then builds a synthetic
+ * command key for the remaining path and delegates to assignGingerly per item.
+ * Nested @each is handled recursively through assignGingerly.
+ */
+function applyCommandToEach(
+  target: any,
+  pathParts: string[],
+  commandSuffix: string,
+  value: any,
+  withMethods: Set<string> | undefined,
+  aliasMap: Map<string, string>,
+  options?: IAssignGingerlyOptions,
+  permissionProcessor?: PermissionProcessor
+): void {
+  const forEachIndex = pathParts.findIndex(part => isForEachSymbol(part, aliasMap));
+  if (forEachIndex === -1) return;
+
+  const pathToForEach = pathParts.slice(0, forEachIndex);
+  const pathAfterForEach = pathParts.slice(forEachIndex + 1);
+
+  const iterable = getIterableAtPath(target, pathToForEach, value, withMethods, permissionProcessor);
+  if (!iterable) return;
+
+  const items = Array.isArray(iterable) ? iterable : Array.from(iterable);
+  const syntheticKey = pathAfterForEach.length > 0
+    ? `?.${pathAfterForEach.join('?.')}${commandSuffix}`
+    : commandSuffix;
+
+  for (const item of items) {
+    assignGingerly(item, { [syntheticKey]: value }, options, permissionProcessor);
+  }
+}
+
 /**
  * Apply alias substitutions to a key string.
  * Replaces complete tokens between `?.` delimiters with their aliased values.
@@ -842,6 +954,12 @@ export function assignGingerly(
         if (isNestedPath(path)) {
           const pathParts = parsePath(path);
 
+          // Check for @each in path
+          if (pathParts.some(part => isForEachSymbol(part, aliasMap))) {
+            applyCommandToEach(target, pathParts, ' +=', value, withMethodsSet, aliasMap, options, permissionProcessor);
+            continue;
+          }
+
           // Check for withMethods path evaluation
           let lhsValue: any;
           let lhsParent: any;
@@ -912,52 +1030,51 @@ export function assignGingerly(
       const lhsPath = parseToggleCommand(key);
       if (lhsPath) {
         const rhsPath = value;
-        
-        // Resolve LHS
-        let lhsParent: any;
-        let lhsLastKey: string;
+
         if (isNestedPath(lhsPath)) {
           const lhsPathParts = parsePath(lhsPath);
-          lhsLastKey = lhsPathParts[lhsPathParts.length - 1];
-          lhsParent = ensureNestedPath(target, lhsPathParts);
-        } else {
-          lhsLastKey = lhsPath;
-          lhsParent = target;
-        }
 
-        // Determine what to negate
-        let valueToNegate;
-        if (rhsPath === '.') {
-          // Self-reference: negate the LHS value itself (if it exists)
-          if (lhsLastKey in lhsParent) {
-            valueToNegate = lhsParent[lhsLastKey];
+          // Check for @each in the LHS path
+          if (lhsPathParts.some(part => isForEachSymbol(part, aliasMap))) {
+            // Resolve non-self-referencing RHS paths against the original target
+            // before iterating, so each item negates the same root value.
+            const resolvedValue = (rhsPath === '.' || typeof rhsPath !== 'string')
+              ? rhsPath
+              : resolveValueToNegate(rhsPath, target);
+            applyCommandToEach(target, lhsPathParts, ' =!', resolvedValue, withMethodsSet, aliasMap, options, permissionProcessor);
+            continue;
+          }
+
+          // No @each in path - standard toggle
+          const lhsLastKey = lhsPathParts[lhsPathParts.length - 1];
+          const lhsParent = ensureNestedPath(target, lhsPathParts);
+
+          // Determine what to negate
+          let valueToNegate: any;
+          if (rhsPath === '.') {
+            valueToNegate = (lhsLastKey in lhsParent) ? lhsParent[lhsLastKey] : undefined;
           } else {
-            valueToNegate = undefined;
+            valueToNegate = resolveValueToNegate(rhsPath, target);
+          }
+
+          if (!permissionProcessor?.checkRestrictedProp(lhsLastKey)) {
+            lhsParent[lhsLastKey] = !valueToNegate;
           }
         } else {
-          // RHS path: navigate to get the value (don't create paths)
-          if (isNestedPath(rhsPath)) {
-            const rhsPathParts = parsePath(rhsPath);
-            let current = target;
-            let exists = true;
-            for (const part of rhsPathParts) {
-              if (current && typeof current === 'object' && part in current) {
-                current = current[part];
-              } else {
-                exists = false;
-                break;
-              }
-            }
-            valueToNegate = exists ? current : true;
+          // Plain key LHS
+          const lhsLastKey = lhsPath;
+          const lhsParent = target;
+
+          let valueToNegate: any;
+          if (rhsPath === '.') {
+            valueToNegate = (lhsLastKey in lhsParent) ? lhsParent[lhsLastKey] : undefined;
           } else {
-            // Plain key RHS
-            valueToNegate = (rhsPath in target) ? target[rhsPath] : true;
+            valueToNegate = resolveValueToNegate(rhsPath, target);
+          }
+
+          if (!permissionProcessor?.checkRestrictedProp(lhsLastKey)) {
+            lhsParent[lhsLastKey] = !valueToNegate;
           }
-        }
-        
-        // Apply negation to LHS — check restriction first
-        if (!permissionProcessor?.checkRestrictedProp(lhsLastKey)) {
-          lhsParent[lhsLastKey] = !valueToNegate;
         }
       }
       continue;
@@ -973,6 +1090,13 @@ export function assignGingerly(
         
         if (isNestedPath(path)) {
           const pathParts = parsePath(path);
+
+          // Check for @each in path
+          if (pathParts.some(part => isForEachSymbol(part, aliasMap))) {
+            applyCommandToEach(target, pathParts, ' -=', value, withMethodsSet, aliasMap, options, permissionProcessor);
+            continue;
+          }
+
           if (pathParts.length === 0) {
             parent = target;
           } else {
@@ -1016,6 +1140,13 @@ export function assignGingerly(
         if (permissionProcessor?.checkRestrictedProp(lastKey)) {
           continue;
         }
+
+        // Check for @each in path
+        if (isNestedPath(path) && pathParts.some(part => isForEachSymbol(part, aliasMap))) {
+          applyCommandToEach(target, pathParts, ' Y=', value, withMethodsSet, aliasMap, options, permissionProcessor);
+          continue;
+        }
+
         // Navigate to the target sub-object
         let mergeTarget: any;
         if (isNestedPath(path)) {
@@ -1083,24 +1214,12 @@ export function assignGingerly(
         // Static forEach (@each) - existing logic
         const pathToForEach = pathParts.slice(0, forEachIndex);
         const pathAfterForEach = pathParts.slice(forEachIndex + 1);
-        
+
         // Navigate to the iterable
-        let current = target;
-        if (pathToForEach.length > 0) {
-          if (withMethodsSet) {
-            const result = evaluatePathWithMethods(target, pathToForEach, value, withMethodsSet, permissionProcessor);
-            // The result.target is the current position after evaluating the path
-            // This is already the iterable we want
-            current = result.target;
-          } else {
-            for (const part of pathToForEach) {
-              current = current[part];
-            }
-          }
-        }
-        
+        const current = getIterableAtPath(target, pathToForEach, value, withMethodsSet, permissionProcessor);
+
         // Apply to each item in the iterable
-        if (isIterable(current)) {
+        if (current) {
           applyToEach(current, pathAfterForEach, value, withMethodsSet || new Set(), aliasMap, options, permissionProcessor);
         }
         // If not iterable, let JavaScript throw error naturally when trying to iterate
@@ -1130,12 +1249,13 @@ export function assignGingerly(
             // Last segment is a method — call it
             const method = result.target[result.lastKey];
             if (typeof method === 'function') {
-              // Trailing | marker - call with no arguments, ignoring the value
+              const appendArgs = capturedPermissionProcessor?.getMethodAppendArgs(result.lastKey) ?? [];
+              // Trailing | marker - call with appended args only, ignoring the value
               const returnVal = result.isZeroArg
-                ? method.call(result.target)
+                ? method.call(result.target, ...appendArgs)
                 : Array.isArray(capturedValue)
-                ? method.apply(result.target, capturedValue)
-                : method.call(result.target, capturedValue);
+                ? method.apply(result.target, [...capturedValue, ...appendArgs])
+                : method.call(result.target, capturedValue, ...appendArgs);
               // If it's an async method, await it (for side effects)
               if (result.isAsyncMethod) await returnVal;
             }
@@ -1171,13 +1291,14 @@ export function assignGingerly(
           // Last segment is a method - call it
           const method = result.target[result.lastKey];
           if (typeof method === 'function') {
+            const appendArgs = permissionProcessor?.getMethodAppendArgs(result.lastKey) ?? [];
             if (result.isZeroArg) {
-              // Trailing | marker - call with no arguments, ignoring the value
-              method.call(result.target);
+              // Trailing | marker - call with appended args only, ignoring the value
+              method.call(result.target, ...appendArgs);
             } else if (Array.isArray(value)) {
-              method.apply(result.target, value);
+              method.apply(result.target, [...value, ...appendArgs]);
             } else {
-              method.call(result.target, value);
+              method.call(result.target, value, ...appendArgs);
             }
           }
           // Silently skip if not a function
@@ -1245,13 +1366,14 @@ export function assignGingerly(
         const methodName = isZeroArgKey ? key.slice(0, -1) : key;
         const method = target[methodName];
         if (typeof method === 'function') {
+          const appendArgs = permissionProcessor?.getMethodAppendArgs(methodName) ?? [];
           if (isZeroArgKey) {
-            // Trailing | marker - call with no arguments, ignoring the value
-            method.call(target);
+            // Trailing | marker - call with appended args only, ignoring the value
+            method.call(target, ...appendArgs);
           } else if (Array.isArray(value)) {
-            method.apply(target, value);
+            method.apply(target, [...value, ...appendArgs]);
           } else {
-            method.call(target, value);
+            method.call(target, value, ...appendArgs);
           }
         }
         // Silently skip if not a function

package/assignPermissions/PermissionProcessor.js

@@ -1,11 +1,14 @@
 import { isAllowedUrl } from './isAllowedUrl.js';
+import { getValue } from '../resolve/getValues.js';
 export class PermissionProcessor {
     constructor(permissions) {
         this.permissions = permissions;
         const { props, attrs } = buildMaps(permissions);
         this.props = props;
         this.attrs = attrs;
-        this.methods = buildMethodSet(permissions);
+        const { blockedMethods, configuredMethods } = buildMethodMaps(permissions);
+        this.blockedMethods = blockedMethods;
+        this.configuredMethods = configuredMethods;
         this.warned = new Set();
         this.warnedMethods = new Set();
     }
@@ -25,11 +28,29 @@ export class PermissionProcessor {
         return true;
     }
     checkRestrictedMethod(methodName) {
-        if (!this.methods.has(methodName))
+        if (!this.blockedMethods.has(methodName))
             return false;
         this.warnRestrictedMethod(methodName);
         return true;
     }
+    getMethodAppendArgs(methodName) {
+        const config = this.configuredMethods.get(methodName);
+        if (!config)
+            return undefined;
+        const rawArgs = config.appendArgs ?? config.addArgs;
+        if (!rawArgs || rawArgs.length === 0)
+            return undefined;
+        const resolved = [];
+        for (const arg of rawArgs) {
+            if (typeof arg === 'string' && arg.startsWith('?.')) {
+                resolved.push(getValue(arg, this.permissions));
+            }
+            else {
+                resolved.push(arg);
+            }
+        }
+        return resolved;
+    }
     redirectRestrictedProp(target, key, value) {
         if (!this.props.has(key))
             return false;
@@ -151,16 +172,22 @@ function normalizeAttrNames(attr, propNames) {
         return propNames;
     return normalizeStrings(attr);
 }
-function buildMethodSet(permissions) {
+function buildMethodMaps(permissions) {
     const methodSettings = permissions?.restrictedMethodSettings;
-    const methods = new Set();
+    const blockedMethods = new Set();
+    const configuredMethods = new Map();
     if (!methodSettings || methodSettings.length === 0) {
-        return methods;
+        return { blockedMethods, configuredMethods };
     }
     for (const setting of methodSettings) {
         if (typeof setting === 'string') {
-            methods.add(setting);
+            blockedMethods.add(setting);
+            continue;
+        }
+        if (configuredMethods.has(setting.method)) {
+            throw new Error(`assignGingerly: duplicate restrictedMethodSettings entry for '${setting.method}'.`);
         }
+        configuredMethods.set(setting.method, setting);
     }
-    return methods;
+    return { blockedMethods, configuredMethods };
 }

package/assignPermissions/PermissionProcessor.ts

@@ -1,4 +1,5 @@
-import type { AssignPermissions, RestrictedPropSetting } from '../types/assign-gingerly/types.js';
+import type { AssignPermissions, RestrictedMethodConfig, RestrictedPropSetting } from '../types/assign-gingerly/types.js';
+import { getValue } from '../resolve/getValues.js';
 import { isAllowedUrl } from './isAllowedUrl.js';
 
 export interface RestrictedPropSettingsMap {
@@ -10,7 +11,8 @@ export class PermissionProcessor {
     private readonly permissions: AssignPermissions | undefined;
     private readonly props: Map<string, RestrictedPropSetting | undefined>;
     private readonly attrs: Map<string, RestrictedPropSetting | undefined>;
-    private readonly methods: Set<string>;
+    private readonly blockedMethods: Set<string>;
+    private readonly configuredMethods: Map<string, RestrictedMethodConfig>;
     private readonly warned = new Set<string>();
     private readonly warnedMethods = new Set<string>();
 
@@ -19,7 +21,9 @@ export class PermissionProcessor {
         const { props, attrs } = buildMaps(permissions);
         this.props = props;
         this.attrs = attrs;
-        this.methods = buildMethodSet(permissions);
+        const { blockedMethods, configuredMethods } = buildMethodMaps(permissions);
+        this.blockedMethods = blockedMethods;
+        this.configuredMethods = configuredMethods;
     }
 
     get crossDomainImports(): boolean {
@@ -41,11 +45,36 @@ export class PermissionProcessor {
     }
 
     checkRestrictedMethod(methodName: string): boolean {
-        if (!this.methods.has(methodName)) return false;
+        if (!this.blockedMethods.has(methodName)) return false;
         this.warnRestrictedMethod(methodName);
         return true;
     }
 
+    /**
+     * Returns the resolved appendArgs for a configured method, if any.
+     * - String entries that start with `?.` are resolved against the permissions object.
+     * - Non-path strings are returned as-is.
+     * - Methods listed as plain strings in restrictedMethodSettings do not return args;
+     *   they are fully blocked via checkRestrictedMethod.
+     */
+    getMethodAppendArgs(methodName: string): any[] | undefined {
+        const config = this.configuredMethods.get(methodName);
+        if (!config) return undefined;
+
+        const rawArgs = config.appendArgs ?? config.addArgs;
+        if (!rawArgs || rawArgs.length === 0) return undefined;
+
+        const resolved: any[] = [];
+        for (const arg of rawArgs) {
+            if (typeof arg === 'string' && arg.startsWith('?.')) {
+                resolved.push(getValue(arg, this.permissions));
+            } else {
+                resolved.push(arg);
+            }
+        }
+        return resolved;
+    }
+
     redirectRestrictedProp(target: any, key: string, value: any): boolean {
         if (!this.props.has(key)) return false;
         const setting = this.props.get(key);
@@ -192,19 +221,25 @@ function normalizeAttrNames(
     return normalizeStrings(attr);
 }
 
-function buildMethodSet(permissions: AssignPermissions | undefined): Set<string> {
+function buildMethodMaps(permissions: AssignPermissions | undefined): { blockedMethods: Set<string>; configuredMethods: Map<string, RestrictedMethodConfig> } {
     const methodSettings = permissions?.restrictedMethodSettings;
-    const methods = new Set<string>();
+    const blockedMethods = new Set<string>();
+    const configuredMethods = new Map<string, RestrictedMethodConfig>();
     if (!methodSettings || methodSettings.length === 0) {
-        return methods;
+        return { blockedMethods, configuredMethods };
     }
 
     for (const setting of methodSettings) {
         if (typeof setting === 'string') {
-            methods.add(setting);
+            blockedMethods.add(setting);
+            continue;
+        }
+
+        if (configuredMethods.has(setting.method)) {
+            throw new Error(`assignGingerly: duplicate restrictedMethodSettings entry for '${setting.method}'.`);
         }
-        // Phase II: object-form RestrictedMethodConfig entries are ignored for now.
+        configuredMethods.set(setting.method, setting);
     }
 
-    return methods;
+    return { blockedMethods, configuredMethods };
 }

package/evaluatePathWithAsyncMethods.js

@@ -43,13 +43,14 @@ export async function evaluatePathWithAsyncMethods(target, pathParts, value, wit
             // Async method — call and await
             const method = current[baseName];
             if (typeof method === 'function') {
+                const appendArgs = permissionProcessor?.getMethodAppendArgs(baseName) ?? [];
                 if (isZeroArgAsync || nextIsMethod) {
                     // Zero-arg call — next is either a method or explicitly not an argument
-                    current = await method.call(current);
+                    current = await method.call(current, ...appendArgs);
                 }
                 else {
                     // Call with next part as string arg, then await
-                    current = await method.call(current, nextPart);
+                    current = await method.call(current, nextPart, ...appendArgs);
                     i++; // Skip next part since we consumed it as argument
                 }
             }
@@ -65,13 +66,14 @@ export async function evaluatePathWithAsyncMethods(target, pathParts, value, wit
             // Sync method — same logic as evaluatePathWithMethods
             const method = current[baseName];
             if (typeof method === 'function') {
+                const appendArgs = permissionProcessor?.getMethodAppendArgs(baseName) ?? [];
                 if (isZeroArgSync || nextIsMethod) {
                     // Zero-arg call — next is either a method or explicitly not an argument
-                    current = method.call(current);
+                    current = method.call(current, ...appendArgs);
                 }
                 else {
                     // Call with next part as string arg
-                    current = method.call(current, nextPart);
+                    current = method.call(current, nextPart, ...appendArgs);
                     i++; // Skip next part since we consumed it as argument
                 }
             }

package/evaluatePathWithAsyncMethods.ts

@@ -69,12 +69,13 @@ export async function evaluatePathWithAsyncMethods(
             // Async method — call and await
             const method = current[baseName];
             if (typeof method === 'function') {
+                const appendArgs = permissionProcessor?.getMethodAppendArgs(baseName) ?? [];
                 if (isZeroArgAsync || nextIsMethod) {
                     // Zero-arg call — next is either a method or explicitly not an argument
-                    current = await method.call(current);
+                    current = await method.call(current, ...appendArgs);
                 } else {
                     // Call with next part as string arg, then await
-                    current = await method.call(current, nextPart);
+                    current = await method.call(current, nextPart, ...appendArgs);
                     i++; // Skip next part since we consumed it as argument
                 }
             } else {
@@ -88,12 +89,13 @@ export async function evaluatePathWithAsyncMethods(
             // Sync method — same logic as evaluatePathWithMethods
             const method = current[baseName];
             if (typeof method === 'function') {
+                const appendArgs = permissionProcessor?.getMethodAppendArgs(baseName) ?? [];
                 if (isZeroArgSync || nextIsMethod) {
                     // Zero-arg call — next is either a method or explicitly not an argument
-                    current = method.call(current);
+                    current = method.call(current, ...appendArgs);
                 } else {
                     // Call with next part as string arg
-                    current = method.call(current, nextPart);
+                    current = method.call(current, nextPart, ...appendArgs);
                     i++; // Skip next part since we consumed it as argument
                 }
             } else {

package/handleIshProperty.js

@@ -47,7 +47,7 @@ async function defineIshProperty(element, managerName, options, assignGingerlyFn
     let config = registry.get(managerName);
     // If not registered, wait for registration
     if (!config) {
-        const { waitForEvent } = await import('./waitForEvent.js');
+        const { waitForEvent } = await import('./utils/waitForEvent.js');
         await waitForEvent(registry, managerName);
         config = registry.get(managerName);
         if (!config) {

package/handleIshProperty.ts

@@ -66,7 +66,7 @@ async function defineIshProperty(
 
   // If not registered, wait for registration
   if (!config) {
-    const { waitForEvent } = await import('./waitForEvent.js');
+    const { waitForEvent } = await import('./utils/waitForEvent.js');
     await waitForEvent(registry, managerName);
     config = registry.get(managerName);