assign-gingerly 0.0.75 → 0.0.77

package/assignGingerly.ts

@@ -1,11 +1,11 @@
 
 
-import { EnhancementConfig } from "./types/assign-gingerly/types";
+import { EnhancementConfig, EnhKey } from "./types/assign-gingerly/types";
 import type { AssignFromOptions, FeatureConfigsMap, IAssignGingerlyOptions } from "./types/assign-gingerly/types";
-import type { AssignPermissions } from './types/assign-gingerly/types.js';
-import { buildRestrictedPropSet, checkRestrictedProp, redirectRestrictedProp } from './assignPermissions/restrictedProps.js';
-import type { RestrictedPropSettingsMap } from './assignPermissions/restrictedProps.js';
-import { normalizeAliasOptions } from './getValues.js';
+import type { PermissionProcessor } from './types/assign-gingerly/types.js';
+import { normalizeAliasOptions } from './resolve/getValues.js';
+
+const DEFAULT_ENHANCEMENT_KEY = Symbol('assign-gingerly.default-enhancement-setup');
 
 /**
  * Constructor signature for ItemScope Manager classes
@@ -74,6 +74,7 @@ export class EnhancementRegisteredEvent extends Event {
  */
 export class EnhancementRegistry extends EventTarget {
   #items: Set<EnhancementConfig> = new Set();
+  #pendingSetups = new Map<EnhKey, Promise<void>[]>();
 
   push(items: EnhancementConfig | EnhancementConfig[]): void {
     if (Array.isArray(items)) {
@@ -85,11 +86,12 @@ export class EnhancementRegistry extends EventTarget {
     // Dispatch event after adding items
     this.dispatchEvent(new EnhancementRegisteredEvent(items));
 
-    // Process features if present (fire-and-forget, uses shared featuresRegistry)
+    // Process features if present (async, tracked so callers can await)
     const itemsArr = Array.isArray(items) ? items : [items];
     for (const item of itemsArr) {
       if (item.features) {
-        this.#assignFeatures(item.spawn, item.features);
+        const promise = this.#assignFeatures(item.spawn, item.features);
+        this._trackSetup(item.enhKey ?? DEFAULT_ENHANCEMENT_KEY, promise);
       }
     }
   }
@@ -99,8 +101,42 @@ export class EnhancementRegistry extends EventTarget {
     const featuresRegistry = (this as any)._featuresRegistry
       ?? (typeof customElements !== 'undefined' ? (customElements as any).featuresRegistry : undefined);
     if (featuresRegistry) {
-      assignFeatures(spawn, features, featuresRegistry);
+      await assignFeatures(spawn, features, featuresRegistry);
+    }
+  }
+
+  /**
+   * Wait for all pending setups for a given enhancement key to complete.
+   * @param enhKey - Enhancement key to wait for
+   */
+  async whenDefined(enhKey: EnhKey): Promise<void> {
+    const pending = this.#pendingSetups.get(enhKey);
+    if (pending && pending.length > 0) {
+      await Promise.all(pending);
+    }
+  }
+
+  /**
+   * Internal method to track a pending setup.
+   * @param name - Setup key
+   * @param promise - Promise representing the setup operation
+   */
+  _trackSetup(name: EnhKey, promise: Promise<void>): void {
+    if (!this.#pendingSetups.has(name)) {
+      this.#pendingSetups.set(name, []);
     }
+    this.#pendingSetups.get(name)!.push(promise);
+
+    // Clean up after completion
+    promise.finally(() => {
+      const pending = this.#pendingSetups.get(name);
+      if (pending) {
+        const index = pending.indexOf(promise);
+        if (index > -1) {
+          pending.splice(index, 1);
+        }
+      }
+    });
   }
 
   getItems(): EnhancementConfig[] {
@@ -153,9 +189,10 @@ export class ItemscopeRegistry extends EventTarget {
     this.#configs.set(name, config);
     this.dispatchEvent(new Event(name));
 
-    // Process features if present (fire-and-forget, uses shared featuresRegistry)
+    // Process features if present (async, tracked so callers can await)
     if ((config as any).features) {
-      this.#assignFeatures(config.manager, (config as any).features);
+      const promise = this.#assignFeatures(config.manager, (config as any).features);
+      this._trackSetup(name, promise);
     }
   }
 
@@ -164,7 +201,7 @@ export class ItemscopeRegistry extends EventTarget {
     const featuresRegistry = (this as any)._featuresRegistry
       ?? (typeof customElements !== 'undefined' ? (customElements as any).featuresRegistry : undefined);
     if (featuresRegistry) {
-      assignFeatures(manager, features, featuresRegistry);
+      await assignFeatures(manager, features, featuresRegistry);
     }
   }
 
@@ -250,30 +287,30 @@ function isIncCommand(key: string): boolean {
 /**
  * Helper function to parse an += command and extract the path
  */
-function parseIncCommand(key: string): string | null {
-  if (!isIncCommand(key)) {
-    return null;
-  }
-  return key.substring(0, key.length - 3); // Remove ' +=' suffix
-}
-
-/**
- * Apply the scalar and array semantics of the += command.
- */
-function addValue(lhs: any, rhs: any): any {
-  if (Array.isArray(lhs)) {
-    return Array.isArray(rhs) ? [...lhs, ...rhs] : [...lhs, rhs];
-  }
-  if (typeof lhs === 'number' && typeof rhs === 'string') {
-    const parsed = Number(rhs);
-    return Number.isNaN(parsed) ? lhs + rhs : lhs + parsed;
-  }
-  if (typeof lhs === 'string' && typeof rhs === 'number') {
-    const parsed = Number(lhs);
-    return Number.isNaN(parsed) ? lhs + rhs : (parsed + rhs).toString();
-  }
-  return lhs + rhs;
-}
+function parseIncCommand(key: string): string | null {
+  if (!isIncCommand(key)) {
+    return null;
+  }
+  return key.substring(0, key.length - 3); // Remove ' +=' suffix
+}
+
+/**
+ * Apply the scalar and array semantics of the += command.
+ */
+function addValue(lhs: any, rhs: any): any {
+  if (Array.isArray(lhs)) {
+    return Array.isArray(rhs) ? [...lhs, ...rhs] : [...lhs, rhs];
+  }
+  if (typeof lhs === 'number' && typeof rhs === 'string') {
+    const parsed = Number(rhs);
+    return Number.isNaN(parsed) ? lhs + rhs : lhs + parsed;
+  }
+  if (typeof lhs === 'string' && typeof rhs === 'number') {
+    const parsed = Number(lhs);
+    return Number.isNaN(parsed) ? lhs + rhs : (parsed + rhs).toString();
+  }
+  return lhs + rhs;
+}
 
 /**
  * Helper function to check if a key represents a =! command
@@ -444,6 +481,19 @@ export function isClassInstance(value: any): boolean {
   return proto !== Object.prototype && proto !== null;
 }
 
+/**
+ * Check whether a method name is listed in withMethods and is not restricted
+ * by the permission processor. Restricted methods are treated as non-method
+ * property names so they fall through to normal access.
+ */
+export function isAllowedMethod(
+  methodName: string,
+  withMethods: Set<string>,
+  permissionProcessor?: PermissionProcessor
+): boolean {
+  return withMethods.has(methodName) && !permissionProcessor?.checkRestrictedMethod(methodName);
+}
+
 /**
  * Helper function to evaluate a nested path with method calls
  * Handles chained method calls where path segments can be methods
@@ -454,7 +504,8 @@ export function evaluatePathWithMethods(
   target: any,
   pathParts: string[],
   value: any,
-  withMethods: Set<string>
+  withMethods: Set<string>,
+  permissionProcessor?: PermissionProcessor
 ): { target: any; lastKey: string; isMethod: boolean; isZeroArg: boolean } {
   let current = target;
   let i = 0;
@@ -466,11 +517,11 @@ export function evaluatePathWithMethods(
     
     // A trailing | marks a zero-argument method call: 'deref|' calls deref()
     // without consuming the next segment. Only applies to names in withMethods.
-    const isZeroArgMethod = part.endsWith('|') && withMethods.has(part.slice(0, -1));
+    const isZeroArgMethod = part.endsWith('|') && isAllowedMethod(part.slice(0, -1), withMethods, permissionProcessor);
     const nextIsMethod = withMethods.has(nextPart)
       || (nextPart.endsWith('|') && withMethods.has(nextPart.slice(0, -1)));
     
-    if (withMethods.has(part) || isZeroArgMethod) {
+    if (isAllowedMethod(part, withMethods, permissionProcessor) || isZeroArgMethod) {
       const methodName = isZeroArgMethod ? part.slice(0, -1) : part;
       const method = current[methodName];
       if (typeof method === 'function') {
@@ -503,12 +554,12 @@ export function evaluatePathWithMethods(
   // 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));
+  const isZeroArg = rawLastKey.endsWith('|') && isAllowedMethod(rawLastKey.slice(0, -1), withMethods, permissionProcessor);
   const lastKey = isZeroArg ? rawLastKey.slice(0, -1) : rawLastKey;
   return {
     target: current,
     lastKey,
-    isMethod: withMethods.has(lastKey),
+    isMethod: isAllowedMethod(lastKey, withMethods, permissionProcessor),
     isZeroArg
   };
 }
@@ -568,8 +619,7 @@ function applyToEach(
   withMethods: Set<string>,
   aliasMap: Map<string, string>,
   options?: IAssignGingerlyOptions,
-  permissions?: AssignPermissions,
-  restrictedPropSet?: RestrictedPropSettingsMap
+  permissionProcessor?: PermissionProcessor
 ): void {
   // Convert to array for iteration
   const items = Array.isArray(iterable) ? iterable : Array.from(iterable);
@@ -594,8 +644,8 @@ function applyToEach(
       let current = item;
       for (const part of pathToForEach) {
         // A trailing | marks a zero-argument method call (only for names in withMethods)
-        const isZeroArgMethod = part.endsWith('|') && withMethods.has(part.slice(0, -1));
-        if (withMethods.has(part) || isZeroArgMethod) {
+        const isZeroArgMethod = part.endsWith('|') && isAllowedMethod(part.slice(0, -1), withMethods, permissionProcessor);
+        if (isAllowedMethod(part, withMethods, permissionProcessor) || isZeroArgMethod) {
           const methodName = isZeroArgMethod ? part.slice(0, -1) : part;
           const method = current[methodName];
           if (typeof method === 'function') {
@@ -627,11 +677,11 @@ function applyToEach(
       
       // Recursively apply to the nested iterable
       if (isIterable(current)) {
-        applyToEach(current, pathAfterForEach, value, withMethods, aliasMap, options, permissions, restrictedPropSet);
+        applyToEach(current, pathAfterForEach, value, withMethods, aliasMap, options, permissionProcessor);
       }
     } else {
       // No nested @each, evaluate the remaining path normally
-      const result = evaluatePathWithMethods(item, remainingPath, value, withMethods);
+      const result = evaluatePathWithMethods(item, remainingPath, value, withMethods, permissionProcessor);
       
       if (result.isMethod) {
         // Last segment is a method - call it
@@ -651,7 +701,7 @@ function applyToEach(
         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)) {
           if (lastKey in parent && isReadonlyProperty(parent, lastKey)) {
@@ -659,7 +709,7 @@ function applyToEach(
             if (typeof currentValue !== 'object' || currentValue === null) {
               throw new Error(`Cannot merge object into readonly primitive property '${String(lastKey)}'`);
             }
-            assignGingerly(currentValue, value, options, permissions);
+            assignGingerly(currentValue, value, options, permissionProcessor);
           } else {
             parent[lastKey] = value;
           }
@@ -702,7 +752,7 @@ export function assignGingerly(
   target: any,
   source: Record<string | symbol, any>,
   options?: IAssignGingerlyOptions,
-  permissions?: AssignPermissions
+  permissionProcessor?: PermissionProcessor
 ): any {
   if (!target || typeof target !== 'object') {
     return target;
@@ -710,9 +760,6 @@ export function assignGingerly(
 
   const { aliasMap, withMethods: withMethodsSet } = normalizeAliasOptions(options);
 
-  // Normalize restrictedPropSettings once per top-level call
-  const restrictedPropSet = buildRestrictedPropSet(permissions);
-
   // Convert withAsyncMethods array to Set for O(1) lookup
   const withAsyncMethodsSet = options?.withAsyncMethods
     ? options.withAsyncMethods instanceof Set
@@ -800,7 +847,7 @@ export function assignGingerly(
           let lhsParent: any;
           let lhsKey: string;
           if (withMethodsSet) {
-            const result = evaluatePathWithMethods(target, pathParts, value, withMethodsSet);
+            const result = evaluatePathWithMethods(target, pathParts, value, withMethodsSet, permissionProcessor);
             lhsParent = result.target;
             lhsKey = result.lastKey;
             lhsValue = lhsParent[lhsKey];
@@ -811,49 +858,49 @@ export function assignGingerly(
           }
 
           //TODO:  this logic seems to occur twice at least.  Maybe make it a method?
-          if (checkRestrictedProp(restrictedPropSet, lhsKey)) {
-            continue;
-          }
-
-          // Event handler: Element LHS + object RHS with 'on' property
+          if (permissionProcessor?.checkRestrictedProp(lhsKey)) {
+            continue;
+          }
+
+          // Event handler: Element LHS + object RHS with 'on' property
           if (lhsValue instanceof Element && value && typeof value === 'object' && !Array.isArray(value) && 'on' in value) {
             const capturedLhs = lhsValue;
             const capturedValue = value;
             const capturedTarget = target;
-            const capturedOptions = options as AssignFromOptions | undefined;
-            import('./handlers/addEventListener.js').then(({ attachEventListener }) => {
-              attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {}, permissions);
+            const capturedOptions = options as AssignFromOptions | undefined;
+            import('./handlers/addEventListener.js').then(({ attachEventListener }) => {
+              attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {}, permissionProcessor);
             });
             continue;
           }
 
-          if (!(lhsKey in lhsParent)) {
-            lhsParent[lhsKey] = value;
-          } else {
-            lhsParent[lhsKey] = addValue(lhsValue, value);
+          if (!(lhsKey in lhsParent)) {
+            lhsParent[lhsKey] = value;
+          } else {
+            lhsParent[lhsKey] = addValue(lhsValue, value);
           }
         } else {
-          // Plain key - direct operation on target
-          if (checkRestrictedProp(restrictedPropSet, path)) {
-            continue;
-          }
-
-          // Event handler: Element LHS + object RHS with 'on' property
+          // Plain key - direct operation on target
+          if (permissionProcessor?.checkRestrictedProp(path)) {
+            continue;
+          }
+
+          // Event handler: Element LHS + object RHS with 'on' property
           if (target[path] instanceof Element && value && typeof value === 'object' && !Array.isArray(value) && 'on' in value) {
             const capturedLhs = target[path];
             const capturedValue = value;
             const capturedTarget = target;
-            const capturedOptions = options as AssignFromOptions | undefined;
-            import('./handlers/addEventListener.js').then(({ attachEventListener }) => {
-              attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {}, permissions);
+            const capturedOptions = options as AssignFromOptions | undefined;
+            import('./handlers/addEventListener.js').then(({ attachEventListener }) => {
+              attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {}, permissionProcessor);
             });
             continue;
           }
 
-          if (!(path in target)) {
-            target[path] = value;
-          } else {
-            target[path] = addValue(target[path], value);
+          if (!(path in target)) {
+            target[path] = value;
+          } else {
+            target[path] = addValue(target[path], value);
           }
         }
       }
@@ -909,7 +956,7 @@ export function assignGingerly(
         }
         
         // Apply negation to LHS — check restriction first
-        if (!checkRestrictedProp(restrictedPropSet, lhsLastKey)) {
+        if (!permissionProcessor?.checkRestrictedProp(lhsLastKey)) {
           lhsParent[lhsLastKey] = !valueToNegate;
         }
       }
@@ -961,19 +1008,19 @@ export function assignGingerly(
     }
 
     // Handle Y= merge commands (recursive assignGingerly into sub-object)
-    if (isMergeCommand(key)) {
-      const path = parseMergeCommand(key);
-      if (path) {
-        const pathParts = isNestedPath(path) ? parsePath(path) : [path];
-        const lastKey = pathParts[pathParts.length - 1];
-        if (checkRestrictedProp(restrictedPropSet, lastKey)) {
-          continue;
-        }
-        // Navigate to the target sub-object
-        let mergeTarget: any;
+    if (isMergeCommand(key)) {
+      const path = parseMergeCommand(key);
+      if (path) {
+        const pathParts = isNestedPath(path) ? parsePath(path) : [path];
+        const lastKey = pathParts[pathParts.length - 1];
+        if (permissionProcessor?.checkRestrictedProp(lastKey)) {
+          continue;
+        }
+        // Navigate to the target sub-object
+        let mergeTarget: any;
         if (isNestedPath(path)) {
           if (withMethodsSet) {
-            const result = evaluatePathWithMethods(target, parsePath(path), value, withMethodsSet);
+            const result = evaluatePathWithMethods(target, parsePath(path), value, withMethodsSet, permissionProcessor);
             mergeTarget = result.target[result.lastKey];
           } else {
             const pathParts = parsePath(path);
@@ -993,7 +1040,7 @@ export function assignGingerly(
         
         // Recursively merge if target is a valid object
         if (mergeTarget && typeof mergeTarget === 'object') {
-          assignGingerly(mergeTarget, value, options, permissions);
+          assignGingerly(mergeTarget, value, options, permissionProcessor);
         }
       }
       continue;
@@ -1021,11 +1068,10 @@ export function assignGingerly(
                 pathParts,
                 forEachIndex,
                 value,
-                withMethodsSet,
-                aliasMap,
-                options,
-                permissions,
-                restrictedPropSet
+                withMethodsSet,
+                aliasMap,
+                options,
+                permissionProcessor
               );
             } catch (error) {
               console.error('Error in @eachTime:', error);
@@ -1042,7 +1088,7 @@ export function assignGingerly(
         let current = target;
         if (pathToForEach.length > 0) {
           if (withMethodsSet) {
-            const result = evaluatePathWithMethods(target, pathToForEach, value, 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;
@@ -1055,7 +1101,7 @@ export function assignGingerly(
         
         // Apply to each item in the iterable
         if (isIterable(current)) {
-          applyToEach(current, pathAfterForEach, value, withMethodsSet || new Set(), aliasMap, options, permissions, restrictedPropSet);
+          applyToEach(current, pathAfterForEach, value, withMethodsSet || new Set(), aliasMap, options, permissionProcessor);
         }
         // If not iterable, let JavaScript throw error naturally when trying to iterate
         
@@ -1069,15 +1115,15 @@ export function assignGingerly(
         const capturedTarget = target;
         const capturedPathParts = pathParts;
         const capturedValue = value;
-        const capturedWithMethodsSet = withMethodsSet || new Set<string>();
-        const capturedOptions = options;
-        const capturedPermissions = permissions;
-        const capturedRestrictedPropSet = restrictedPropSet;
+        const capturedWithMethodsSet = withMethodsSet || new Set<string>();
+        const capturedOptions = options;
+        const capturedPermissionProcessor = permissionProcessor;
         (async () => {
           const { evaluatePathWithAsyncMethods } = await import('./evaluatePathWithAsyncMethods.js');
           const result = await evaluatePathWithAsyncMethods(
             capturedTarget, capturedPathParts, capturedValue,
-            capturedWithMethodsSet, withAsyncMethodsSet
+            capturedWithMethodsSet, withAsyncMethodsSet,
+            capturedPermissionProcessor
           );
 
           if (result.isMethod || result.isAsyncMethod) {
@@ -1096,16 +1142,16 @@ export function assignGingerly(
           } else {
             // Not a method — assign the value
             const lastKey = result.lastKey;
-            const parent = result.target;
-            if (redirectRestrictedProp(capturedRestrictedPropSet, parent, lastKey, capturedValue)) {
-              // skip
-            } else if (typeof capturedValue === 'object' && capturedValue !== null && !Array.isArray(capturedValue)) {
+            const parent = result.target;
+            if (capturedPermissionProcessor?.redirectRestrictedProp(parent, lastKey, capturedValue)) {
+              // skip
+            } else if (typeof capturedValue === 'object' && capturedValue !== null && !Array.isArray(capturedValue)) {
               if (lastKey in parent && isReadonlyProperty(parent, lastKey)) {
                 const currentValue = parent[lastKey];
                 if (typeof currentValue !== 'object' || currentValue === null) {
                   throw new Error(`Cannot merge object into readonly primitive property '${String(lastKey)}'`);
                 }
-                assignGingerly(currentValue, capturedValue, capturedOptions, capturedPermissions);
+                assignGingerly(currentValue, capturedValue, capturedOptions, capturedPermissionProcessor);
               } else {
                 parent[lastKey] = capturedValue;
               }
@@ -1119,7 +1165,7 @@ export function assignGingerly(
 
       // Check if we need to handle methods
       if (withMethodsSet) {
-        const result = evaluatePathWithMethods(target, pathParts, value, withMethodsSet);
+        const result = evaluatePathWithMethods(target, pathParts, value, withMethodsSet, permissionProcessor);
         
         if (result.isMethod) {
           // Last segment is a method - call it
@@ -1142,19 +1188,19 @@ export function assignGingerly(
         const lastKey = result.lastKey;
         const parent = result.target;
         
-        if (redirectRestrictedProp(restrictedPropSet, parent, lastKey, value)) {
-          // skip
-        // Check for static assignTo protocol
-        } else if (lastKey in parent && tryAssignTo(parent[lastKey], value, parent, lastKey)) {
-          continue;
-        } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        if (permissionProcessor?.redirectRestrictedProp(parent, lastKey, value)) {
+          // skip
+        // Check for static assignTo protocol
+        } else if (lastKey in parent && tryAssignTo(parent[lastKey], value, parent, lastKey)) {
+          continue;
+        } 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];
             if (typeof currentValue !== 'object' || currentValue === null) {
               throw new Error(`Cannot merge object into readonly primitive property '${String(lastKey)}'`);
             }
-            assignGingerly(currentValue, value, options, permissions);
+            assignGingerly(currentValue, value, options, permissionProcessor);
           } else {
             // Property is writable - replace it
             parent[lastKey] = value;
@@ -1167,12 +1213,12 @@ export function assignGingerly(
         const lastKey = pathParts[pathParts.length - 1];
         const parent = ensureNestedPath(target, pathParts);
 
-        if (redirectRestrictedProp(restrictedPropSet, parent, lastKey, value)) {
-          // skip
-        // Check for static assignTo protocol
-        } else if (lastKey in parent && tryAssignTo(parent[lastKey], value, parent, lastKey)) {
-          continue;
-        } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        if (permissionProcessor?.redirectRestrictedProp(parent, lastKey, value)) {
+          // skip
+        // Check for static assignTo protocol
+        } else if (lastKey in parent && tryAssignTo(parent[lastKey], value, parent, lastKey)) {
+          continue;
+        } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
           // Check if property exists and is readonly
           if (lastKey in parent && isReadonlyProperty(parent, lastKey)) {
             // Property is readonly - check if current value is an object
@@ -1181,7 +1227,7 @@ export function assignGingerly(
               throw new Error(`Cannot merge object into readonly primitive property '${String(lastKey)}'`);
             }
             // Recursively apply assignGingerly to the readonly object
-            assignGingerly(currentValue, value, options, permissions);
+            assignGingerly(currentValue, value, options, permissionProcessor);
           } else {
             // Property is writable - replace it
             parent[lastKey] = value;
@@ -1212,12 +1258,12 @@ export function assignGingerly(
         continue;
       }
       
-      if (redirectRestrictedProp(restrictedPropSet, target, key, value)) {
-        // skip
-      // Check for static assignTo protocol
-      } else if (key in target && tryAssignTo(target[key], value, target, key)) {
-        continue;
-      } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      if (permissionProcessor?.redirectRestrictedProp(target, key, value)) {
+        // skip
+      // Check for static assignTo protocol
+      } else if (key in target && tryAssignTo(target[key], value, target, key)) {
+        continue;
+      } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
         // Check if property exists and is readonly
         if (key in target && isReadonlyProperty(target, key)) {
           // Property is readonly - check if current value is an object
@@ -1226,7 +1272,7 @@ export function assignGingerly(
             throw new Error(`Cannot merge object into readonly primitive property '${String(key)}'`);
           }
           // Recursively apply assignGingerly to the readonly object
-          assignGingerly(currentValue, value, options, permissions);
+          assignGingerly(currentValue, value, options, permissionProcessor);
         } else {
           // Property is writable - replace it
           target[key] = value;
@@ -1370,7 +1416,7 @@ export function assignGingerly(
   // Fire-and-forget bulk enhancements (async, non-blocking)
   if (options?.enhance && options.enhance.length > 0 && typeof target === 'object' && target instanceof Element) {
     import('./enhanceAll.js').then(({ enhanceAll }) => {
-      enhanceAll(target, options!.enhance!, permissions);
+      enhanceAll(target, options!.enhance!, permissionProcessor);
     });
   }