assign-gingerly 0.0.74 → 0.0.76

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

package/handlers/lazyLoad.ts

@@ -20,11 +20,11 @@
  */
 
 import type { AssignFromHandler } from '../assignFromAsync.js';
-import type { LazyLoadResolvedParams, LazyLoadInstantiatedContext } from '../types/assign-gingerly/types.js';
+import type { LazyLoadResolvedParams, LazyLoadInstantiatedContext, PermissionProcessor } from '../types/assign-gingerly/types.js';
 import { withTransition, ensureHideStyle, DEFAULT_HIDE_CLASS } from '../transitionHelper.js';
 import { findMarkers, createMarkers, getNodesBetweenMarkers, findMarkersSibling, createMarkersSibling, MARKER_START_PREFIX, MARKER_END } from '../markerUtils.js';
 import { assignFrom } from '../assignFrom.js';
-import type { AssignPermissions } from '../types/assign-gingerly/types.js';
+
 
 export type { LazyLoadResolvedParams, LazyLoadInstantiatedContext };
 
@@ -49,16 +49,16 @@ function getMarkerName(templateEl: any): string {
 export class LazyLoadHandler implements AssignFromHandler {
     config: any;
     _options: any;
-    _permissions?: AssignPermissions;
+    _permissionProcessor?: PermissionProcessor;
     static #markerCounter = 0;
 
     constructor(config: any) {
         this.config = config;
     }
 
-    async assign(lhsTarget: any, resolvedParams: LazyLoadResolvedParams, options?: any, permissions?: AssignPermissions): Promise<void> {
+    async assign(lhsTarget: any, resolvedParams: LazyLoadResolvedParams, options?: any, permissionProcessor?: PermissionProcessor): Promise<void> {
         this._options = options; // Store for applyAssign access
-        this._permissions = permissions;
+        this._permissionProcessor = permissionProcessor;
         const {
             if: condition,
             instantiate,
@@ -320,10 +320,10 @@ export class LazyLoadHandler implements AssignFromHandler {
             const len = Math.min(elements.length, assign.configs.length);
             for (let j = 0; j < len; j++) {
                 const cfg = assign.configs[j];
-                assignFrom(elements[j], cfg.toClone ?? {}, { from, ...cfg.withOptions }, this._permissions);
+                assignFrom(elements[j], cfg.toClone ?? {}, { from, ...cfg.withOptions }, this._permissionProcessor);
             }
         } else if (assign.toClone) {
-            assignFrom(elements[0], assign.toClone, { from, ...assign.withOptions }, this._permissions);
+            assignFrom(elements[0], assign.toClone, { from, ...assign.withOptions }, this._permissionProcessor);
         }
     }
 

package/handlers/lazyLoadSwitch.ts

@@ -21,7 +21,7 @@
  */
 
 import { LazyLoadHandler } from './lazyLoad.js';
-import type { AssignPermissions } from '../types/assign-gingerly/types.js';
+import type { PermissionProcessor } from '../types/assign-gingerly/types.js';
 import type { AssignFromHandler } from '../assignFromAsync.js';
 import type { LazyLoadSwitchResolvedParams } from '../types/assign-gingerly/types.js';
 
@@ -56,10 +56,10 @@ function evaluateOp(lhs: any, op: string, rhs: any): boolean {
  */
 export class LazyLoadSwitchHandler extends LazyLoadHandler implements AssignFromHandler {
 
-    async assign(lhsTarget: any, resolvedParams: LazyLoadSwitchResolvedParams, options?: any, permissions?: AssignPermissions): Promise<void> {
+    async assign(lhsTarget: any, resolvedParams: LazyLoadSwitchResolvedParams, options?: any, permissionProcessor?: PermissionProcessor): Promise<void> {
         const { lhs, op = '===', rhs, ...rest } = resolvedParams;
         const condition = evaluateOp(lhs, op, rhs);
         // Delegate to parent with computed condition
-        return super.assign(lhsTarget, { ...rest, if: condition }, options, permissions);
+        return super.assign(lhsTarget, { ...rest, if: condition }, options, permissionProcessor);
     }
 }

package/handlers/manageTemplateList.js

@@ -25,7 +25,7 @@
  * }, { from: vm, withMethods: ['querySelector'], protocols: { globalThis: k => globalThis[k] } });
  */
 import { findMarkers, createMarkers } from '../markerUtils.js';
-import { resolveValue } from '../resolveValues.js';
+import { resolveValue } from '../resolve/resolveValues.js';
 import { assignFrom } from '../assignFrom.js';
 import { processInferredAssignments } from '../inferredAssignments.js';
 /**
@@ -55,7 +55,7 @@ export class ManageTemplateListHandler {
     constructor(config) {
         this.config = config;
     }
-    async assign(lhsTarget, resolvedParams, options, permissions) {
+    async assign(lhsTarget, resolvedParams, options, permissionProcessor) {
         //return;
         const { forEach: items, instantiate, method = 'appendChild', forget = false, markerName, yieldEvery, } = resolvedParams;
         if (!(lhsTarget instanceof Element)) {
@@ -143,7 +143,7 @@ export class ManageTemplateListHandler {
                     const len = Math.min(elements.length, configs.length);
                     for (let j = 0; j < len; j++) {
                         const cfg = configs[j];
-                        assignFrom(elements[j], cfg.toClone ?? {}, { from: item, ...cfg.withOptions }, permissions);
+                        assignFrom(elements[j], cfg.toClone ?? {}, { from: item, ...cfg.withOptions }, permissionProcessor);
                     }
                 }
                 else {
@@ -153,13 +153,13 @@ export class ManageTemplateListHandler {
                             processInferred(rootEl, item, inferredConfig === true ? { byItemprop: true } : inferredConfig);
                         }
                         else {
-                            assignFrom(rootEl, toClone, { from: item, ...withOptions }, permissions);
+                            assignFrom(rootEl, toClone, { from: item, ...withOptions }, permissionProcessor);
                         }
                         if (hostToClone && options?.from) {
-                            assignFrom(rootEl, hostToClone, { from: options.from, ...hostWithOptions }, permissions);
+                            assignFrom(rootEl, hostToClone, { from: options.from, ...hostWithOptions }, permissionProcessor);
                         }
                         if (targetToClone) {
-                            assignFrom(rootEl, targetToClone, { from: lhsTarget, ...targetWithOptions }, permissions);
+                            assignFrom(rootEl, targetToClone, { from: lhsTarget, ...targetWithOptions }, permissionProcessor);
                         }
                     }
                 }
@@ -192,7 +192,7 @@ export class ManageTemplateListHandler {
                     const len = Math.min(elements.length, configs.length);
                     for (let j = 0; j < len; j++) {
                         const cfg = configs[j];
-                        assignFrom(elements[j], cfg.toClone ?? {}, { from: item, ...cfg.withOptions }, permissions);
+                        assignFrom(elements[j], cfg.toClone ?? {}, { from: item, ...cfg.withOptions }, permissionProcessor);
                     }
                 }
                 else {
@@ -204,13 +204,13 @@ export class ManageTemplateListHandler {
                             processInferred(rootEl, item, inferredConfig === true ? { byItemprop: true } : inferredConfig);
                         }
                         else {
-                            assignFrom(rootEl, toClone, { from: item, ...withOptions }, permissions);
+                            assignFrom(rootEl, toClone, { from: item, ...withOptions }, permissionProcessor);
                         }
                         if (hostToClone && options?.from) {
-                            assignFrom(rootEl, hostToClone, { from: options.from, ...hostWithOptions }, permissions);
+                            assignFrom(rootEl, hostToClone, { from: options.from, ...hostWithOptions }, permissionProcessor);
                         }
                         if (targetToClone) {
-                            assignFrom(rootEl, targetToClone, { from: lhsTarget, ...targetWithOptions }, permissions);
+                            assignFrom(rootEl, targetToClone, { from: lhsTarget, ...targetWithOptions }, permissionProcessor);
                         }
                     }
                 }