assign-gingerly 0.0.75 → 0.0.77

package/assignFromAsync.ts

@@ -19,11 +19,10 @@
  * }, { from: source });
  * // target is now { color: 'red', text: 'Hello' }
  */
-import { resolveValues } from './resolveValues.js';
+import { resolveValues } from './resolve/resolveValues.js';
 import {IAssignGingerlyOptions} from './types/assign-gingerly/types.js';
 import assignGingerly from './assignGingerly.js';
-import type { AssignPermissions } from './types/assign-gingerly/types.js';
-import type { AssignFromHandler, AssignFromHandlerConstructor } from './types/assign-gingerly/types.js';
+import type { PermissionProcessor, AssignFromHandler, AssignFromHandlerConstructor } from './types/assign-gingerly/types.js';
 import {
   expandSubstitutions, categorizeKeys, handleSpreads, isHandlerCommand
 } from './assignFrom.js';
@@ -56,7 +55,7 @@ export async function assignFromAsync(
   target: any,
   pattern: Record<string, any>,
   options: AssignFromOptions,
-  permissions?: AssignPermissions
+  permissionProcessor?: PermissionProcessor
 ): Promise<any> {
   // First: expand looped substitution variables (${x}, ${y}, ${z})
   const expandedPattern = expandSubstitutions(pattern, options);
@@ -71,19 +70,20 @@ export async function assignFromAsync(
       aka: options.aka,
       akaMethods: options.akaMethods,
       protocols: options.protocols,
-      root: target
+      root: target,
+      permissionProcessor
     });
 
     // Recursively handle "..." spread keys at all nesting levels
     handleSpreads(resolved);
 
-    assignGingerly(target, resolved, options, permissions);
+    assignGingerly(target, resolved, options, permissionProcessor);
   }
 
   // Process #[x] normal keys — resolve element, then apply remaining path + value
   if (idRefNormalKeys.length > 0 && (options.pin || options.at)) {
     const ids = { ...options.pin, ...options.at };
-    const { resolveIdVariable, parseIdRef } = await import('./resolveIdRef.js');
+    const { resolveIdVariable, parseIdRef } = await import('./resolve/resolveIdRef.js');
     const { withMethods, aka, akaMethods, protocols, from } = options;
     for (const key of idRefNormalKeys) {
       const parsed = parseIdRef(key);
@@ -97,21 +97,21 @@ export async function assignFromAsync(
         // Resolve the RHS value
         const resolvedValue = await resolveValues(
           { __v: value }, from,
-          { withMethods, aka, akaMethods, protocols, root: el }
+          { withMethods, aka, akaMethods, protocols, root: el, permissionProcessor }
         );
         // Apply remaining path on the resolved element
-        assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options, permissions);
+        assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options, permissionProcessor);
       } else {
         // No remaining path — resolve and assign directly to the element
         const resolvedValue = await resolveValues(
           typeof value === 'object' && value !== null ? value : { __v: value },
           from,
-          { withMethods, aka, akaMethods, protocols, root: el }
+          { withMethods, aka, akaMethods, protocols, root: el, permissionProcessor }
         );
         if ('__v' in resolvedValue) {
           // Single value — can't assign to element root without a path
         } else {
-          assignGingerly(el, resolvedValue, options, permissions);
+          assignGingerly(el, resolvedValue, options, permissionProcessor);
         }
       }
     }
@@ -120,12 +120,12 @@ export async function assignFromAsync(
   if (handlerKeys.length > 0) {
     
     _processHandlerCommands ??= (await import('./processHandlerCommands.js')).processHandlerCommands;
-    await _processHandlerCommands(target, handlerKeys, expandedPattern, options, permissions);
+    await _processHandlerCommands(target, handlerKeys, expandedPattern, options, permissionProcessor);
   }
   // Process #[x] handler keys — resolve element, then pass to handler processing
   if (idRefHandlerKeys.length > 0 && (options.pin || options.at)) {
     const ids = { ...options.pin, ...options.at };
-    const { resolveIdVariable, parseIdRef } = await import('./resolveIdRef.js');
+    const { resolveIdVariable, parseIdRef } = await import('./resolve/resolveIdRef.js');
     _processHandlerCommands ??= (await import('./processHandlerCommands.js')).processHandlerCommands;
 
     for (const key of idRefHandlerKeys) {
@@ -145,7 +145,7 @@ export async function assignFromAsync(
         [syntheticKey]: expandedPattern[key]
       };
 
-      await _processHandlerCommands(el, [syntheticKey], syntheticPattern, options, permissions);
+      await _processHandlerCommands(el, [syntheticKey], syntheticPattern, options, permissionProcessor);
     }
   }
 
@@ -167,7 +167,7 @@ export async function assignFromAsync(
   // Process bulk enhancements — dynamically imported only when option is present
   if (options.enhance && options.enhance.length > 0) {
     const { enhanceAll } = await import('./enhanceAll.js');
-    await enhanceAll(target, options.enhance, permissions);
+    await enhanceAll(target, options.enhance, permissionProcessor);
   }
 
   return target;

package/assignGingerly.js

@@ -1,5 +1,5 @@
-import { buildRestrictedPropSet, checkRestrictedProp, redirectRestrictedProp } from './assignPermissions/restrictedProps.js';
-import { normalizeAliasOptions } from './getValues.js';
+import { normalizeAliasOptions } from './resolve/getValues.js';
+const DEFAULT_ENHANCEMENT_KEY = Symbol('assign-gingerly.default-enhancement-setup');
 /**
  * GUID for global instance map storage to ensure uniqueness across package versions
  */
@@ -35,6 +35,7 @@ export class EnhancementRegisteredEvent extends Event {
  */
 export class EnhancementRegistry extends EventTarget {
     #items = new Set();
+    #pendingSetups = new Map();
     push(items) {
         if (Array.isArray(items)) {
             items.forEach(item => this.#items.add(item));
@@ -44,11 +45,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);
             }
         }
     }
@@ -57,9 +59,40 @@ export class EnhancementRegistry extends EventTarget {
         const featuresRegistry = this._featuresRegistry
             ?? (typeof customElements !== 'undefined' ? customElements.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) {
+        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, promise) {
+        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() {
         return Array.from(this.#items);
     }
@@ -106,9 +139,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.features) {
-            this.#assignFeatures(config.manager, config.features);
+            const promise = this.#assignFeatures(config.manager, config.features);
+            this._trackSetup(name, promise);
         }
     }
     async #assignFeatures(manager, features) {
@@ -116,7 +150,7 @@ export class ItemscopeRegistry extends EventTarget {
         const featuresRegistry = this._featuresRegistry
             ?? (typeof customElements !== 'undefined' ? customElements.featuresRegistry : undefined);
         if (featuresRegistry) {
-            assignFeatures(manager, features, featuresRegistry);
+            await assignFeatures(manager, features, featuresRegistry);
         }
     }
     /**
@@ -369,13 +403,21 @@ export function isClassInstance(value) {
     // Plain objects have Object.prototype or null as prototype
     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, withMethods, permissionProcessor) {
+    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
  *
  * Exported for use by eachTime.ts
  */
-export function evaluatePathWithMethods(target, pathParts, value, withMethods) {
+export function evaluatePathWithMethods(target, pathParts, value, withMethods, permissionProcessor) {
     let current = target;
     let i = 0;
     // Process all segments except the last one
@@ -384,10 +426,10 @@ export function evaluatePathWithMethods(target, pathParts, value, withMethods) {
         const nextPart = pathParts[i + 1];
         // 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') {
@@ -421,12 +463,12 @@ export function evaluatePathWithMethods(target, pathParts, value, withMethods) {
     // 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
     };
 }
@@ -474,7 +516,7 @@ function isReactiveForEachSymbol(segment, aliasMap) {
 /**
  * Apply a path to each item in an iterable
  */
-function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, options, permissions, restrictedPropSet) {
+function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, options, permissionProcessor) {
     // Convert to array for iteration
     const items = Array.isArray(iterable) ? iterable : Array.from(iterable);
     // Apply the remaining path to each item
@@ -494,8 +536,8 @@ function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, opti
             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') {
@@ -530,12 +572,12 @@ function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, opti
             }
             // 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
                 const method = result.target[result.lastKey];
@@ -556,7 +598,7 @@ function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, opti
                 // 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)) {
@@ -565,7 +607,7 @@ function applyToEach(iterable, remainingPath, value, withMethods, aliasMap, opti
                         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;
@@ -602,13 +644,11 @@ function applyAliases(key, aliasMap) {
 /**
  * Main assignGingerly function
  */
-export function assignGingerly(target, source, options, permissions) {
+export function assignGingerly(target, source, options, permissionProcessor) {
     if (!target || typeof target !== 'object') {
         return target;
     }
     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
@@ -689,7 +729,7 @@ export function assignGingerly(target, source, options, permissions) {
                     let lhsParent;
                     let lhsKey;
                     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];
@@ -700,7 +740,7 @@ export function assignGingerly(target, source, options, permissions) {
                         lhsValue = lhsParent[lhsKey];
                     }
                     //TODO:  this logic seems to occur twice at least.  Maybe make it a method?
-                    if (checkRestrictedProp(restrictedPropSet, lhsKey)) {
+                    if (permissionProcessor?.checkRestrictedProp(lhsKey)) {
                         continue;
                     }
                     // Event handler: Element LHS + object RHS with 'on' property
@@ -710,7 +750,7 @@ export function assignGingerly(target, source, options, permissions) {
                         const capturedTarget = target;
                         const capturedOptions = options;
                         import('./handlers/addEventListener.js').then(({ attachEventListener }) => {
-                            attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {}, permissions);
+                            attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {}, permissionProcessor);
                         });
                         continue;
                     }
@@ -723,7 +763,7 @@ export function assignGingerly(target, source, options, permissions) {
                 }
                 else {
                     // Plain key - direct operation on target
-                    if (checkRestrictedProp(restrictedPropSet, path)) {
+                    if (permissionProcessor?.checkRestrictedProp(path)) {
                         continue;
                     }
                     // Event handler: Element LHS + object RHS with 'on' property
@@ -733,7 +773,7 @@ export function assignGingerly(target, source, options, permissions) {
                         const capturedTarget = target;
                         const capturedOptions = options;
                         import('./handlers/addEventListener.js').then(({ attachEventListener }) => {
-                            attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {}, permissions);
+                            attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {}, permissionProcessor);
                         });
                         continue;
                     }
@@ -798,7 +838,7 @@ export function assignGingerly(target, source, options, permissions) {
                     }
                 }
                 // Apply negation to LHS — check restriction first
-                if (!checkRestrictedProp(restrictedPropSet, lhsLastKey)) {
+                if (!permissionProcessor?.checkRestrictedProp(lhsLastKey)) {
                     lhsParent[lhsLastKey] = !valueToNegate;
                 }
             }
@@ -855,14 +895,14 @@ export function assignGingerly(target, source, options, permissions) {
             if (path) {
                 const pathParts = isNestedPath(path) ? parsePath(path) : [path];
                 const lastKey = pathParts[pathParts.length - 1];
-                if (checkRestrictedProp(restrictedPropSet, lastKey)) {
+                if (permissionProcessor?.checkRestrictedProp(lastKey)) {
                     continue;
                 }
                 // Navigate to the target sub-object
                 let mergeTarget;
                 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 {
@@ -884,7 +924,7 @@ export function assignGingerly(target, source, options, permissions) {
                 }
                 // Recursively merge if target is a valid object
                 if (mergeTarget && typeof mergeTarget === 'object') {
-                    assignGingerly(mergeTarget, value, options, permissions);
+                    assignGingerly(mergeTarget, value, options, permissionProcessor);
                 }
             }
             continue;
@@ -901,7 +941,7 @@ export function assignGingerly(target, source, options, permissions) {
                     (async () => {
                         try {
                             const { handleEachTime } = await import('./eachTime.js');
-                            await handleEachTime(target, pathParts, forEachIndex, value, withMethodsSet, aliasMap, options, permissions, restrictedPropSet);
+                            await handleEachTime(target, pathParts, forEachIndex, value, withMethodsSet, aliasMap, options, permissionProcessor);
                         }
                         catch (error) {
                             console.error('Error in @eachTime:', error);
@@ -916,7 +956,7 @@ export function assignGingerly(target, source, options, permissions) {
                 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;
@@ -929,7 +969,7 @@ export function assignGingerly(target, source, options, permissions) {
                 }
                 // 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
                 continue;
@@ -943,11 +983,10 @@ export function assignGingerly(target, source, options, permissions) {
                 const capturedValue = value;
                 const capturedWithMethodsSet = withMethodsSet || new Set();
                 const capturedOptions = options;
-                const capturedPermissions = permissions;
-                const capturedRestrictedPropSet = restrictedPropSet;
+                const capturedPermissionProcessor = permissionProcessor;
                 (async () => {
                     const { evaluatePathWithAsyncMethods } = await import('./evaluatePathWithAsyncMethods.js');
-                    const result = await evaluatePathWithAsyncMethods(capturedTarget, capturedPathParts, capturedValue, capturedWithMethodsSet, withAsyncMethodsSet);
+                    const result = await evaluatePathWithAsyncMethods(capturedTarget, capturedPathParts, capturedValue, capturedWithMethodsSet, withAsyncMethodsSet, capturedPermissionProcessor);
                     if (result.isMethod || result.isAsyncMethod) {
                         // Last segment is a method — call it
                         const method = result.target[result.lastKey];
@@ -967,7 +1006,7 @@ export function assignGingerly(target, source, options, permissions) {
                         // Not a method — assign the value
                         const lastKey = result.lastKey;
                         const parent = result.target;
-                        if (redirectRestrictedProp(capturedRestrictedPropSet, parent, lastKey, capturedValue)) {
+                        if (capturedPermissionProcessor?.redirectRestrictedProp(parent, lastKey, capturedValue)) {
                             // skip
                         }
                         else if (typeof capturedValue === 'object' && capturedValue !== null && !Array.isArray(capturedValue)) {
@@ -976,7 +1015,7 @@ export function assignGingerly(target, source, options, permissions) {
                                 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;
@@ -991,7 +1030,7 @@ export function assignGingerly(target, source, options, permissions) {
             }
             // 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
                     const method = result.target[result.lastKey];
@@ -1013,7 +1052,7 @@ export function assignGingerly(target, source, options, permissions) {
                 // Not a method - proceed with normal assignment using evaluated target
                 const lastKey = result.lastKey;
                 const parent = result.target;
-                if (redirectRestrictedProp(restrictedPropSet, parent, lastKey, value)) {
+                if (permissionProcessor?.redirectRestrictedProp(parent, lastKey, value)) {
                     // skip
                     // Check for static assignTo protocol
                 }
@@ -1027,7 +1066,7 @@ export function assignGingerly(target, source, options, permissions) {
                         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
@@ -1042,7 +1081,7 @@ export function assignGingerly(target, source, options, permissions) {
                 // No withMethods - use original logic
                 const lastKey = pathParts[pathParts.length - 1];
                 const parent = ensureNestedPath(target, pathParts);
-                if (redirectRestrictedProp(restrictedPropSet, parent, lastKey, value)) {
+                if (permissionProcessor?.redirectRestrictedProp(parent, lastKey, value)) {
                     // skip
                     // Check for static assignTo protocol
                 }
@@ -1058,7 +1097,7 @@ export function assignGingerly(target, source, options, permissions) {
                             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
@@ -1092,7 +1131,7 @@ export function assignGingerly(target, source, options, permissions) {
                 // Silently skip if not a function
                 continue;
             }
-            if (redirectRestrictedProp(restrictedPropSet, target, key, value)) {
+            if (permissionProcessor?.redirectRestrictedProp(target, key, value)) {
                 // skip
                 // Check for static assignTo protocol
             }
@@ -1108,7 +1147,7 @@ export function assignGingerly(target, source, options, permissions) {
                         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
@@ -1235,7 +1274,7 @@ export function assignGingerly(target, source, options, permissions) {
     // 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);
         });
     }
     return target;