assign-gingerly 0.0.75 → 0.0.77

package/eachTime.js

@@ -3,7 +3,6 @@
  * This module is dynamically loaded only when @eachTime is encountered
  * Provides event-driven iteration over elements as they mount
  */
-import { redirectRestrictedProp } from './assignPermissions/restrictedProps.js';
 /**
  * Check if a value is an EventTarget
  */
@@ -21,7 +20,7 @@ function isEventTarget(value) {
  * @param aliasMap - Map of aliases for token substitution
  * @param options - Options including required AbortSignal
  */
-export async function handleEachTime(target, pathParts, forEachIndex, value, withMethods, aliasMap, options, permissions, restrictedPropSet) {
+export async function handleEachTime(target, pathParts, forEachIndex, value, withMethods, aliasMap, options, permissionProcessor) {
     // Validate signal - required for cleanup
     if (!options?.signal) {
         throw new Error('@eachTime requires an AbortSignal in options.signal for cleanup');
@@ -35,7 +34,7 @@ export async function handleEachTime(target, pathParts, forEachIndex, value, wit
         // Import evaluatePathWithMethods for navigation
         const { evaluatePathWithMethods } = await import('./assignGingerly.js');
         if (withMethods && withMethods.size > 0) {
-            const result = evaluatePathWithMethods(target, pathToEventSource, value, withMethods);
+            const result = evaluatePathWithMethods(target, pathToEventSource, value, withMethods, permissionProcessor);
             eventSource = result.target;
         }
         else {
@@ -61,7 +60,7 @@ export async function handleEachTime(target, pathParts, forEachIndex, value, wit
                 // Import needed functions from assignGingerly
                 const { evaluatePathWithMethods, assignGingerly, isReadonlyProperty } = await import('./assignGingerly.js');
                 if (pathAfterForEach.length > 0) {
-                    const result = evaluatePathWithMethods(mountedElement, pathAfterForEach, value, withMethods || new Set());
+                    const result = evaluatePathWithMethods(mountedElement, pathAfterForEach, value, withMethods || new Set(), permissionProcessor);
                     if (result.isMethod) {
                         // Last segment is a method - call it
                         const method = result.target[result.lastKey];
@@ -82,7 +81,7 @@ export async function handleEachTime(target, pathParts, forEachIndex, value, wit
                         // Normal assignment
                         const lastKey = result.lastKey;
                         const parent = result.target;
-                        if (redirectRestrictedProp(restrictedPropSet, parent, lastKey, value)) {
+                        if (permissionProcessor?.redirectRestrictedProp(parent, lastKey, value)) {
                             // skip
                         }
                         else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
@@ -93,7 +92,7 @@ export async function handleEachTime(target, pathParts, forEachIndex, value, wit
                                     throw new Error(`Cannot merge object into readonly primitive property '${String(lastKey)}'`);
                                 }
                                 // Recursively apply assignGingerly
-                                assignGingerly(currentValue, value, options, permissions);
+                                assignGingerly(currentValue, value, options, permissionProcessor);
                             }
                             else {
                                 // Property is writable - replace it

package/eachTime.ts

@@ -4,10 +4,7 @@
  * Provides event-driven iteration over elements as they mount
  */
 
-import type { IAssignGingerlyOptions } from './types/assign-gingerly/types.js';
-import type { AssignPermissions } from './types/assign-gingerly/types.js';
-import { redirectRestrictedProp } from './assignPermissions/restrictedProps.js';
-import type { RestrictedPropSettingsMap } from './assignPermissions/restrictedProps.js';
+import type { PermissionProcessor, IAssignGingerlyOptions } from './types/assign-gingerly/types.js';
 
 /**
  * Check if a value is an EventTarget
@@ -32,11 +29,10 @@ export async function handleEachTime(
   pathParts: string[],
   forEachIndex: number,
   value: any,
-  withMethods: Set<string> | undefined,
-  aliasMap: Map<string, string>,
-  options?: IAssignGingerlyOptions,
-  permissions?: AssignPermissions,
-  restrictedPropSet?: RestrictedPropSettingsMap
+  withMethods: Set<string> | undefined,
+  aliasMap: Map<string, string>,
+  options?: IAssignGingerlyOptions,
+  permissionProcessor?: PermissionProcessor
 ): Promise<void> {
   // Validate signal - required for cleanup
   if (!options?.signal) {
@@ -54,7 +50,7 @@ export async function handleEachTime(
     const { evaluatePathWithMethods } = await import('./assignGingerly.js');
     
     if (withMethods && withMethods.size > 0) {
-      const result = evaluatePathWithMethods(target, pathToEventSource, value, withMethods);
+      const result = evaluatePathWithMethods(target, pathToEventSource, value, withMethods, permissionProcessor);
       eventSource = result.target;
     } else {
       // Simple property navigation
@@ -90,7 +86,8 @@ export async function handleEachTime(
             mountedElement, 
             pathAfterForEach, 
             value, 
-            withMethods || new Set()
+            withMethods || new Set(),
+            permissionProcessor
           );
           
           if (result.isMethod) {
@@ -111,9 +108,9 @@ export async function handleEachTime(
             const lastKey = result.lastKey;
             const parent = result.target;
             
-            if (redirectRestrictedProp(restrictedPropSet, parent, lastKey, value)) {
-              // skip
-            } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            if (permissionProcessor?.redirectRestrictedProp(parent, lastKey, value)) {
+              // skip
+            } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
               // Check if property exists and is readonly
               if (lastKey in parent && isReadonlyProperty(parent, lastKey)) {
                 const currentValue = parent[lastKey];
@@ -123,7 +120,7 @@ export async function handleEachTime(
                   );
                 }
                 // Recursively apply assignGingerly
-                assignGingerly(currentValue, value, options, permissions);
+                assignGingerly(currentValue, value, options, permissionProcessor);
               } else {
                 // Property is writable - replace it
                 parent[lastKey] = value;

package/enhanceAll.js

@@ -33,13 +33,13 @@ import { findClassPrototypeInPath } from './utils/findClassPrototypeInPath.js';
  * @param target - The DOM element to search within
  * @param configs - Array of enhancement configurations
  */
-export async function enhanceAll(target, configs, permissions) {
+export async function enhanceAll(target, configs, permissionProcessor) {
     for (const config of configs) {
         // Validate EMC path unless cross-domain imports are explicitly permitted
-        if (!permissions?.crossDomainImports && !isAllowedImportPath(config.emc)) {
+        if (!permissionProcessor?.crossDomainImports && !isAllowedImportPath(config.emc)) {
             throw new Error(`enhanceAll: EMC path "${config.emc}" is a cross-domain URL. ` +
                 `Only same-origin paths or import-map-covered specifiers are allowed by default. ` +
-                `Pass { crossDomainImports: true } in permissions to override.`);
+                `Pass { crossDomainImports: true } in permissionProcessor to override.`);
         }
         // 1. Import the EMC JSON
         const emcModule = await import(config.emc, { with: { type: 'json' } });

package/enhanceAll.ts

@@ -18,7 +18,7 @@
 
 import { isAllowedImportPath } from './assignPermissions/isAllowedImportPath.js';
 import { findClassPrototypeInPath } from './utils/findClassPrototypeInPath.js';
-import type { AssignPermissions } from './types/assign-gingerly/types.js';
+import type { PermissionProcessor } from './types/assign-gingerly/types.js';
 
 /**
  * Configuration for a single enhancement to apply in bulk.
@@ -51,15 +51,15 @@ export interface EnhanceConfig {
 export async function enhanceAll(
     target: Element,
     configs: EnhanceConfig[],
-    permissions?: AssignPermissions
+    permissionProcessor?: PermissionProcessor
 ): Promise<void> {
     for (const config of configs) {
         // Validate EMC path unless cross-domain imports are explicitly permitted
-        if (!permissions?.crossDomainImports && !isAllowedImportPath(config.emc)) {
+        if (!permissionProcessor?.crossDomainImports && !isAllowedImportPath(config.emc)) {
             throw new Error(
                 `enhanceAll: EMC path "${config.emc}" is a cross-domain URL. ` +
                 `Only same-origin paths or import-map-covered specifiers are allowed by default. ` +
-                `Pass { crossDomainImports: true } in permissions to override.`
+                `Pass { crossDomainImports: true } in permissionProcessor to override.`
             );
         }
 

package/evaluatePathWithAsyncMethods.js

@@ -10,6 +10,10 @@
  * NOTE: Interaction with @each and @eachTime is not yet implemented.
  * Deferred until a compelling use case presents itself.
  */
+import { isAllowedMethod } from './assignGingerly.js';
+function isAllowedAsyncMethod(methodName, withAsyncMethods, permissionProcessor) {
+    return withAsyncMethods.has(methodName) && !permissionProcessor?.checkRestrictedMethod(methodName);
+}
 /**
  * Evaluates a path with support for both sync and async method calls.
  * Awaits the return value of any method in the withAsyncMethods set.
@@ -21,7 +25,7 @@
  * @param withAsyncMethods - Set of method names that are awaited
  * @returns Promise resolving to the evaluation result
  */
-export async function evaluatePathWithAsyncMethods(target, pathParts, value, withMethods, withAsyncMethods) {
+export async function evaluatePathWithAsyncMethods(target, pathParts, value, withMethods, withAsyncMethods, permissionProcessor) {
     let current = target;
     let i = 0;
     // Process all segments except the last one
@@ -30,12 +34,12 @@ export async function evaluatePathWithAsyncMethods(target, pathParts, value, wit
         const nextPart = pathParts[i + 1];
         // A trailing | marks a zero-argument method call: 'deref|' calls deref()
         // without consuming the next segment. Only applies to listed method names.
-        const isZeroArgSync = part.endsWith('|') && withMethods.has(part.slice(0, -1));
-        const isZeroArgAsync = part.endsWith('|') && withAsyncMethods.has(part.slice(0, -1));
+        const isZeroArgSync = part.endsWith('|') && isAllowedMethod(part.slice(0, -1), withMethods, permissionProcessor);
+        const isZeroArgAsync = part.endsWith('|') && isAllowedAsyncMethod(part.slice(0, -1), withAsyncMethods, permissionProcessor);
         const baseName = (isZeroArgSync || isZeroArgAsync) ? part.slice(0, -1) : part;
         const nextIsMethod = withAsyncMethods.has(nextPart) || withMethods.has(nextPart)
             || (nextPart.endsWith('|') && (withAsyncMethods.has(nextPart.slice(0, -1)) || withMethods.has(nextPart.slice(0, -1))));
-        if (withAsyncMethods.has(part) || isZeroArgAsync) {
+        if (isAllowedAsyncMethod(part, withAsyncMethods, permissionProcessor) || isZeroArgAsync) {
             // Async method — call and await
             const method = current[baseName];
             if (typeof method === 'function') {
@@ -57,7 +61,7 @@ export async function evaluatePathWithAsyncMethods(target, pathParts, value, wit
                 current = current[baseName];
             }
         }
-        else if (withMethods.has(part) || isZeroArgSync) {
+        else if (isAllowedMethod(part, withMethods, permissionProcessor) || isZeroArgSync) {
             // Sync method — same logic as evaluatePathWithMethods
             const method = current[baseName];
             if (typeof method === 'function') {
@@ -91,13 +95,13 @@ export async function evaluatePathWithAsyncMethods(target, pathParts, value, wit
     // otherwise it is a literal property name (e.g. an exotic key ending in |).
     const rawLastKey = pathParts[pathParts.length - 1];
     const isZeroArg = rawLastKey.endsWith('|')
-        && (withMethods.has(rawLastKey.slice(0, -1)) || withAsyncMethods.has(rawLastKey.slice(0, -1)));
+        && (isAllowedMethod(rawLastKey.slice(0, -1), withMethods, permissionProcessor) || isAllowedAsyncMethod(rawLastKey.slice(0, -1), withAsyncMethods, permissionProcessor));
     const lastKey = isZeroArg ? rawLastKey.slice(0, -1) : rawLastKey;
     return {
         target: current,
         lastKey,
-        isMethod: withMethods.has(lastKey),
-        isAsyncMethod: withAsyncMethods.has(lastKey),
+        isMethod: isAllowedMethod(lastKey, withMethods, permissionProcessor),
+        isAsyncMethod: isAllowedAsyncMethod(lastKey, withAsyncMethods, permissionProcessor),
         isZeroArg
     };
 }

package/evaluatePathWithAsyncMethods.ts

@@ -1,117 +1,129 @@
-/**
- * evaluatePathWithAsyncMethods - Async variant of evaluatePathWithMethods.
- * 
- * Walks a path of property accesses and method calls, awaiting any methods
- * that are in the withAsyncMethods set before continuing the chain.
- * 
- * This module is loaded dynamically (only when withAsyncMethods is used)
- * to avoid adding async overhead to the synchronous path.
- * 
- * NOTE: Interaction with @each and @eachTime is not yet implemented.
- * Deferred until a compelling use case presents itself.
- */
-
-export interface AsyncPathResult {
-    target: any;
-    lastKey: string;
-    isMethod: boolean;
-    isAsyncMethod: boolean;
-    isZeroArg: boolean;
-}
-
-/**
- * Evaluates a path with support for both sync and async method calls.
- * Awaits the return value of any method in the withAsyncMethods set.
- * 
- * @param target - The root object to start path evaluation from
- * @param pathParts - Array of path segments (split from '?.' notation)
- * @param value - The value to assign or pass as argument at the end
- * @param withMethods - Set of method names that are called synchronously
- * @param withAsyncMethods - Set of method names that are awaited
- * @returns Promise resolving to the evaluation result
- */
-export async function evaluatePathWithAsyncMethods(
-    target: any,
-    pathParts: string[],
-    value: any,
-    withMethods: Set<string>,
-    withAsyncMethods: Set<string>
-): Promise<AsyncPathResult> {
-    let current = target;
-    let i = 0;
-
-    // Process all segments except the last one
-    while (i < pathParts.length - 1) {
-        const part = pathParts[i];
-        const nextPart = pathParts[i + 1];
-
-        // A trailing | marks a zero-argument method call: 'deref|' calls deref()
-        // without consuming the next segment. Only applies to listed method names.
-        const isZeroArgSync = part.endsWith('|') && withMethods.has(part.slice(0, -1));
-        const isZeroArgAsync = part.endsWith('|') && withAsyncMethods.has(part.slice(0, -1));
-        const baseName = (isZeroArgSync || isZeroArgAsync) ? part.slice(0, -1) : part;
-        const nextIsMethod = withAsyncMethods.has(nextPart) || withMethods.has(nextPart)
-            || (nextPart.endsWith('|') && (withAsyncMethods.has(nextPart.slice(0, -1)) || withMethods.has(nextPart.slice(0, -1))));
-
-        if (withAsyncMethods.has(part) || isZeroArgAsync) {
-            // Async method — call and await
-            const method = current[baseName];
-            if (typeof method === 'function') {
-                if (isZeroArgAsync || nextIsMethod) {
-                    // Zero-arg call — next is either a method or explicitly not an argument
-                    current = await method.call(current);
-                } else {
-                    // Call with next part as string arg, then await
-                    current = await method.call(current, nextPart);
-                    i++; // Skip next part since we consumed it as argument
-                }
-            } else {
-                // Not a function — just access property
-                if (current[baseName] === undefined || current[baseName] === null) {
-                    current[baseName] = {};
-                }
-                current = current[baseName];
-            }
-        } else if (withMethods.has(part) || isZeroArgSync) {
-            // Sync method — same logic as evaluatePathWithMethods
-            const method = current[baseName];
-            if (typeof method === 'function') {
-                if (isZeroArgSync || nextIsMethod) {
-                    // Zero-arg call — next is either a method or explicitly not an argument
-                    current = method.call(current);
-                } else {
-                    // Call with next part as string arg
-                    current = method.call(current, nextPart);
-                    i++; // Skip next part since we consumed it as argument
-                }
-            } else {
-                if (!(baseName in current) || typeof current[baseName] !== 'object' || current[baseName] === null) {
-                    current[baseName] = {};
-                }
-                current = current[baseName];
-            }
-        } else {
-            // Not a method — normal property access
-            if (!(part in current) || typeof current[part] !== 'object' || current[part] === null) {
-                current[part] = {};
-            }
-            current = current[part];
-        }
-
-        i++;
-    }
-
-    // Strip a trailing | from the last segment only when it names a listed method;
-    // otherwise it is a literal property name (e.g. an exotic key ending in |).
-    const rawLastKey = pathParts[pathParts.length - 1];
-    const isZeroArg = rawLastKey.endsWith('|')
-        && (withMethods.has(rawLastKey.slice(0, -1)) || withAsyncMethods.has(rawLastKey.slice(0, -1)));
-    const lastKey = isZeroArg ? rawLastKey.slice(0, -1) : rawLastKey;
-    return {
-        target: current,
-        lastKey,
-        isMethod: withMethods.has(lastKey),
-        isAsyncMethod: withAsyncMethods.has(lastKey),
-        isZeroArg
-    };
-}
+/**
+ * evaluatePathWithAsyncMethods - Async variant of evaluatePathWithMethods.
+ * 
+ * Walks a path of property accesses and method calls, awaiting any methods
+ * that are in the withAsyncMethods set before continuing the chain.
+ * 
+ * This module is loaded dynamically (only when withAsyncMethods is used)
+ * to avoid adding async overhead to the synchronous path.
+ * 
+ * NOTE: Interaction with @each and @eachTime is not yet implemented.
+ * Deferred until a compelling use case presents itself.
+ */
+
+import type { PermissionProcessor } from './types/assign-gingerly/types.js';
+import { isAllowedMethod } from './assignGingerly.js';
+
+export interface AsyncPathResult {
+    target: any;
+    lastKey: string;
+    isMethod: boolean;
+    isAsyncMethod: boolean;
+    isZeroArg: boolean;
+}
+
+function isAllowedAsyncMethod(
+    methodName: string,
+    withAsyncMethods: Set<string>,
+    permissionProcessor?: PermissionProcessor
+): boolean {
+    return withAsyncMethods.has(methodName) && !permissionProcessor?.checkRestrictedMethod(methodName);
+}
+
+/**
+ * Evaluates a path with support for both sync and async method calls.
+ * Awaits the return value of any method in the withAsyncMethods set.
+ * 
+ * @param target - The root object to start path evaluation from
+ * @param pathParts - Array of path segments (split from '?.' notation)
+ * @param value - The value to assign or pass as argument at the end
+ * @param withMethods - Set of method names that are called synchronously
+ * @param withAsyncMethods - Set of method names that are awaited
+ * @returns Promise resolving to the evaluation result
+ */
+export async function evaluatePathWithAsyncMethods(
+    target: any,
+    pathParts: string[],
+    value: any,
+    withMethods: Set<string>,
+    withAsyncMethods: Set<string>,
+    permissionProcessor?: PermissionProcessor
+): Promise<AsyncPathResult> {
+    let current = target;
+    let i = 0;
+
+    // Process all segments except the last one
+    while (i < pathParts.length - 1) {
+        const part = pathParts[i];
+        const nextPart = pathParts[i + 1];
+
+        // A trailing | marks a zero-argument method call: 'deref|' calls deref()
+        // without consuming the next segment. Only applies to listed method names.
+        const isZeroArgSync = part.endsWith('|') && isAllowedMethod(part.slice(0, -1), withMethods, permissionProcessor);
+        const isZeroArgAsync = part.endsWith('|') && isAllowedAsyncMethod(part.slice(0, -1), withAsyncMethods, permissionProcessor);
+        const baseName = (isZeroArgSync || isZeroArgAsync) ? part.slice(0, -1) : part;
+        const nextIsMethod = withAsyncMethods.has(nextPart) || withMethods.has(nextPart)
+            || (nextPart.endsWith('|') && (withAsyncMethods.has(nextPart.slice(0, -1)) || withMethods.has(nextPart.slice(0, -1))));
+
+        if (isAllowedAsyncMethod(part, withAsyncMethods, permissionProcessor) || isZeroArgAsync) {
+            // Async method — call and await
+            const method = current[baseName];
+            if (typeof method === 'function') {
+                if (isZeroArgAsync || nextIsMethod) {
+                    // Zero-arg call — next is either a method or explicitly not an argument
+                    current = await method.call(current);
+                } else {
+                    // Call with next part as string arg, then await
+                    current = await method.call(current, nextPart);
+                    i++; // Skip next part since we consumed it as argument
+                }
+            } else {
+                // Not a function — just access property
+                if (current[baseName] === undefined || current[baseName] === null) {
+                    current[baseName] = {};
+                }
+                current = current[baseName];
+            }
+        } else if (isAllowedMethod(part, withMethods, permissionProcessor) || isZeroArgSync) {
+            // Sync method — same logic as evaluatePathWithMethods
+            const method = current[baseName];
+            if (typeof method === 'function') {
+                if (isZeroArgSync || nextIsMethod) {
+                    // Zero-arg call — next is either a method or explicitly not an argument
+                    current = method.call(current);
+                } else {
+                    // Call with next part as string arg
+                    current = method.call(current, nextPart);
+                    i++; // Skip next part since we consumed it as argument
+                }
+            } else {
+                if (!(baseName in current) || typeof current[baseName] !== 'object' || current[baseName] === null) {
+                    current[baseName] = {};
+                }
+                current = current[baseName];
+            }
+        } else {
+            // Not a method — normal property access
+            if (!(part in current) || typeof current[part] !== 'object' || current[part] === null) {
+                current[part] = {};
+            }
+            current = current[part];
+        }
+
+        i++;
+    }
+
+    // Strip a trailing | from the last segment only when it names a listed method;
+    // otherwise it is a literal property name (e.g. an exotic key ending in |).
+    const rawLastKey = pathParts[pathParts.length - 1];
+    const isZeroArg = rawLastKey.endsWith('|')
+        && (isAllowedMethod(rawLastKey.slice(0, -1), withMethods, permissionProcessor) || isAllowedAsyncMethod(rawLastKey.slice(0, -1), withAsyncMethods, permissionProcessor));
+    const lastKey = isZeroArg ? rawLastKey.slice(0, -1) : rawLastKey;
+    return {
+        target: current,
+        lastKey,
+        isMethod: isAllowedMethod(lastKey, withMethods, permissionProcessor),
+        isAsyncMethod: isAllowedAsyncMethod(lastKey, withAsyncMethods, permissionProcessor),
+        isZeroArg
+    };
+}

package/handlers/addEventListener.js

@@ -37,7 +37,7 @@ function extractShorthand(config) {
 /**
  * Process a single AssignDispatchVector — execute all toTarget/toHost/toLHS assignments.
  */
-function processVector(vector, source, target, host, lhs, inheritedOptions, useAssignFrom, permissions) {
+function processVector(vector, source, target, host, lhs, inheritedOptions, useAssignFrom, permissionProcessor) {
     const destinations = [
         { key: 'toTarget', dest: target },
         { key: 'toHost', dest: host },
@@ -50,11 +50,11 @@ function processVector(vector, source, target, host, lhs, inheritedOptions, useA
         if (useAssignFrom && source != null) {
             // Dynamic import assignFrom on demand (fire-and-forget context, already async)
             import('../assignFrom.js').then(({ assignFrom }) => {
-                assignFrom(dest, pattern, { from: source, ...inheritedOptions, ...vector.withOptions }, permissions);
+                assignFrom(dest, pattern, { from: source, ...inheritedOptions, ...vector.withOptions }, permissionProcessor);
             });
         }
         else {
-            assignGingerly(dest, pattern, inheritedOptions, permissions);
+            assignGingerly(dest, pattern, inheritedOptions, permissionProcessor);
         }
     }
     // Handle shorthand (implicit toHost)
@@ -62,11 +62,11 @@ function processVector(vector, source, target, host, lhs, inheritedOptions, useA
     if (shorthand) {
         if (useAssignFrom && source != null) {
             import('../assignFrom.js').then(({ assignFrom }) => {
-                assignFrom(host, shorthand, { from: source, ...inheritedOptions, ...vector.withOptions }, permissions);
+                assignFrom(host, shorthand, { from: source, ...inheritedOptions, ...vector.withOptions }, permissionProcessor);
             });
         }
         else {
-            assignGingerly(host, shorthand, inheritedOptions, permissions);
+            assignGingerly(host, shorthand, inheritedOptions, permissionProcessor);
         }
     }
 }
@@ -79,7 +79,7 @@ function processVector(vector, source, target, host, lhs, inheritedOptions, useA
  * @param host - The options.from (source/view model)
  * @param inheritedOptions - Parent assignFrom options (withMethods, aka, etc.)
  */
-export function attachEventListener(lhs, config, target, host, inheritedOptions, permissions) {
+export function attachEventListener(lhs, config, target, host, inheritedOptions, permissionProcessor) {
     const { on: eventName, get: getConfig, fromLHS, fromHost, fromTarget, fromEvent, dispatch } = config;
     // Resolve get config values
     const { abortController, key, nudge, options: listenerOptions, stopPropagation, preventDefault, dispatch: getDispatch } = getConfig ?? {};
@@ -112,22 +112,22 @@ export function attachEventListener(lhs, config, target, host, inheritedOptions,
         if (preventDefault)
             event.preventDefault();
         // Static assignments (no from) — top-level toTarget/toHost/toLHS + shorthand
-        processVector(config, null, target, host, lhs, inheritedOptions, false, permissions);
+        processVector(config, null, target, host, lhs, inheritedOptions, false, permissionProcessor);
         // fromLHS assignments
         if (fromLHS) {
-            processVector(fromLHS, lhs, target, host, lhs, inheritedOptions, true, permissions);
+            processVector(fromLHS, lhs, target, host, lhs, inheritedOptions, true, permissionProcessor);
         }
         // fromHost assignments
         if (fromHost) {
-            processVector(fromHost, host, target, host, lhs, inheritedOptions, true, permissions);
+            processVector(fromHost, host, target, host, lhs, inheritedOptions, true, permissionProcessor);
         }
         // fromTarget assignments
         if (fromTarget) {
-            processVector(fromTarget, target, target, host, lhs, inheritedOptions, true, permissions);
+            processVector(fromTarget, target, target, host, lhs, inheritedOptions, true, permissionProcessor);
         }
         // fromEvent assignments
         if (fromEvent) {
-            processVector(fromEvent, event, target, host, lhs, inheritedOptions, true, permissions);
+            processVector(fromEvent, event, target, host, lhs, inheritedOptions, true, permissionProcessor);
         }
         // Dispatch custom event if configured
         const dispatchConfig = dispatch || getDispatch;

package/handlers/addEventListener.ts

@@ -8,8 +8,7 @@
  */
 
 import assignGingerly from '../assignGingerly.js';
-import type { AddEventListenerConfig, AssignDispatchVector } from '../types/assign-gingerly/types.js';
-import type { AssignPermissions } from '../types/assign-gingerly/types.js';
+import type { AddEventListenerConfig, AssignDispatchVector, PermissionProcessor } from '../types/assign-gingerly/types.js';
 
 /**
  * WeakMap for dedup: Element → Map<key, AbortController>
@@ -52,7 +51,7 @@ function processVector(
     lhs: Element,
     inheritedOptions: any,
     useAssignFrom: boolean,
-    permissions?: AssignPermissions
+    permissionProcessor?: PermissionProcessor
 ): void {
     const destinations = [
         { key: 'toTarget' as const, dest: target },
@@ -66,10 +65,10 @@ function processVector(
         if (useAssignFrom && source != null) {
             // Dynamic import assignFrom on demand (fire-and-forget context, already async)
             import('../assignFrom.js').then(({ assignFrom }) => {
-                assignFrom(dest, pattern, { from: source, ...inheritedOptions, ...vector.withOptions }, permissions);
+                assignFrom(dest, pattern, { from: source, ...inheritedOptions, ...vector.withOptions }, permissionProcessor);
             });
         } else {
-            assignGingerly(dest, pattern, inheritedOptions, permissions);
+            assignGingerly(dest, pattern, inheritedOptions, permissionProcessor);
         }
     }
 
@@ -78,10 +77,10 @@ function processVector(
     if (shorthand) {
         if (useAssignFrom && source != null) {
             import('../assignFrom.js').then(({ assignFrom }) => {
-                assignFrom(host, shorthand, { from: source, ...inheritedOptions, ...vector.withOptions }, permissions);
+                assignFrom(host, shorthand, { from: source, ...inheritedOptions, ...vector.withOptions }, permissionProcessor);
             });
         } else {
-            assignGingerly(host, shorthand, inheritedOptions, permissions);
+            assignGingerly(host, shorthand, inheritedOptions, permissionProcessor);
         }
     }
 }
@@ -101,7 +100,7 @@ export function attachEventListener(
     target: any,
     host: any,
     inheritedOptions: any,
-    permissions?: AssignPermissions
+    permissionProcessor?: PermissionProcessor
 ): void {
     const { on: eventName, get: getConfig, fromLHS, fromHost, fromTarget, fromEvent, dispatch } = config;
 
@@ -134,26 +133,26 @@ export function attachEventListener(
         if (preventDefault) event.preventDefault();
 
         // Static assignments (no from) — top-level toTarget/toHost/toLHS + shorthand
-        processVector(config, null, target, host, lhs, inheritedOptions, false, permissions);
+        processVector(config, null, target, host, lhs, inheritedOptions, false, permissionProcessor);
 
         // fromLHS assignments
         if (fromLHS) {
-            processVector(fromLHS, lhs, target, host, lhs, inheritedOptions, true, permissions);
+            processVector(fromLHS, lhs, target, host, lhs, inheritedOptions, true, permissionProcessor);
         }
 
         // fromHost assignments
         if (fromHost) {
-            processVector(fromHost, host, target, host, lhs, inheritedOptions, true, permissions);
+            processVector(fromHost, host, target, host, lhs, inheritedOptions, true, permissionProcessor);
         }
 
         // fromTarget assignments
         if (fromTarget) {
-            processVector(fromTarget, target, target, host, lhs, inheritedOptions, true, permissions);
+            processVector(fromTarget, target, target, host, lhs, inheritedOptions, true, permissionProcessor);
         }
 
         // fromEvent assignments
         if (fromEvent) {
-            processVector(fromEvent, event, target, host, lhs, inheritedOptions, true, permissions);
+            processVector(fromEvent, event, target, host, lhs, inheritedOptions, true, permissionProcessor);
         }
 
         // Dispatch custom event if configured