assign-gingerly 0.0.69 → 0.0.71

package/DX/emojis.js

@@ -34,11 +34,14 @@ export const akaMethods = {
     '🧺': 'querySelectorAll',
     '+': 'add',
     '🧬': 'cloneNode',
-    '🔤': 'textContent',
 };
 export const aka = {
     '©️': 'content?.cloneNode?.true',
     //'🔎': 'clone?.querySelector'
+    // textContent is a property, not a method — aliasing it via akaMethods
+    // would add it to withMethods and turn `?.textContent` assignments into
+    // silently-skipped method calls.
+    '🔤': 'textContent',
 };
 export const emojis = {
     builtInEmoji,

package/DX/emojis.ts

@@ -36,12 +36,15 @@ export const akaMethods: Record<string, string> = {
     '🧺': 'querySelectorAll',
     '+': 'add',
     '🧬': 'cloneNode',
-    '🔤': 'textContent',
 };
 
 export const aka: Record<string, string> = {
     '©️': 'content?.cloneNode?.true',
     //'🔎': 'clone?.querySelector'
+    // textContent is a property, not a method — aliasing it via akaMethods
+    // would add it to withMethods and turn `?.textContent` assignments into
+    // silently-skipped method calls.
+    '🔤': 'textContent',
 };
 
 

package/DX/installForwarding.ts

@@ -21,8 +21,9 @@
  * // Now el.command delegates to el.behaviors.commandBehavior.command
  */
 
-import { resolveValue, ResolveValuesOptions } from '../resolveValues.js';
-import assignGingerly, { IAssignGingerlyOptions } from '../assignGingerly.js';
+import { resolveValue} from '../resolveValues.js';
+import {ResolveValuesOptions, IAssignGingerlyOptions} from '../types/assign-gingerly/types.js';
+import assignGingerly, {  } from '../assignGingerly.js';
 
 export interface InstallForwardingOptions extends ResolveValuesOptions, IAssignGingerlyOptions {}
 

package/DX/pinCorrector.ts

@@ -14,7 +14,7 @@ function computeChildPath(root: Element, target: Element): number[] | null {
     let current: Element | null = target;
 
     while (current && current !== root) {
-        const parent = current.parentElement;
+        const parent = current.parentElement as HTMLElement | null;
         if (!parent) return null;
         const idx = Array.prototype.indexOf.call(parent.children, current);
         if (idx === -1) return null;

package/assignFrom.js

@@ -68,6 +68,29 @@ function resolveTernaryValue(value, source, options) {
     }
     return value;
 }
+/**
+ * Check if a value in a result position is a nested ternary expression.
+ * Trigger: an array of length ≥ 2 whose first element is a `?.`-prefixed
+ * string (truthiness mode) or an array (comparison mode). Other arrays
+ * are treated as literal values.
+ */
+function isNestedTernary(value) {
+    if (!Array.isArray(value) || value.length < 2)
+        return false;
+    const first = value[0];
+    return Array.isArray(first) || (typeof first === 'string' && first.startsWith('?.'));
+}
+/**
+ * Resolve a value in a result position (then/else/neither, comparison results,
+ * chain candidates). Nested ternary expressions are evaluated recursively;
+ * everything else goes through resolveTernaryValue.
+ */
+function resolveResult(value, source, options) {
+    if (isNestedTernary(value)) {
+        return evaluateTernary(value, source, options);
+    }
+    return resolveTernaryValue(value, source, options);
+}
 /**
  * Evaluate a ?= ternary expression.
  *
@@ -77,8 +100,12 @@ function resolveTernaryValue(value, source, options) {
  * - [ifTrue, trueResult, falseResult, neither]     — three-state (true/false/nullish)
  * - [[lhs, rhs], ifEqual, ifNotEqual?]             — equality comparison
  * - [[lhs, rhs], ifEqual]                          — equality guard
+ * - [c1, '||', c2, '||', c3, ...]                  — first truthy candidate (c1 || c2 || c3)
+ * - [c1, '??', c2, '??', c3, ...]                  — first non-nullish candidate (c1 ?? c2 ?? c3)
+ * - [c1, t1, [c2, t2, e2]]                         — nested ternary in any result position
  *
- * Returns undefined to signal "skip assignment" (guard forms when condition not met).
+ * Returns TERNARY_SKIP to signal "skip assignment" (guard forms when condition
+ * not met). A skip from a nested guard propagates outward.
  */
 const TERNARY_SKIP = Symbol('ternary-skip');
 function evaluateTernary(arr, source, options) {
@@ -90,10 +117,10 @@ function evaluateTernary(arr, source, options) {
             // Equality: [[lhs, rhs], result, elseResult?]
             const rhs = resolveTernaryValue(condition[1], source, options);
             if (lhs === rhs) {
-                return resolveTernaryValue(arr[1], source, options);
+                return resolveResult(arr[1], source, options);
             }
             else {
-                return arr.length > 2 ? resolveTernaryValue(arr[2], source, options) : TERNARY_SKIP;
+                return arr.length > 2 ? resolveResult(arr[2], source, options) : TERNARY_SKIP;
             }
         }
         else {
@@ -102,32 +129,79 @@ function evaluateTernary(arr, source, options) {
             const rhs = resolveTernaryValue(condition[2], source, options);
             const satisfied = compareWithOp(lhs, op, rhs);
             if (satisfied) {
-                return resolveTernaryValue(arr[1], source, options);
+                return resolveResult(arr[1], source, options);
             }
             else {
-                return arr.length > 2 ? resolveTernaryValue(arr[2], source, options) : TERNARY_SKIP;
+                return arr.length > 2 ? resolveResult(arr[2], source, options) : TERNARY_SKIP;
             }
         }
     }
     else {
+        // Chain shortcut: [c1, '||', c2, ...] or [c1, '??', c2, ...]
+        // Checked before the length-based dispatch so a length-4 chain
+        // isn't misread as the three-state form.
+        if (arr[1] === '||' || arr[1] === '??') {
+            return evaluateChain(arr, source, options);
+        }
         // Truthiness mode
         const resolved = resolveTernaryValue(condition, source, options);
         if (arr.length === 4) {
             // [ifTrue, trueResult, falseResult, neitherResult]
             if (resolved == null)
-                return resolveTernaryValue(arr[3], source, options);
-            return resolved ? resolveTernaryValue(arr[1], source, options) : resolveTernaryValue(arr[2], source, options);
+                return resolveResult(arr[3], source, options);
+            return resolved ? resolveResult(arr[1], source, options) : resolveResult(arr[2], source, options);
         }
         else if (arr.length === 3) {
             // [ifTruthy, thenResult, elseResult]
-            return resolved ? resolveTernaryValue(arr[1], source, options) : resolveTernaryValue(arr[2], source, options);
+            return resolved ? resolveResult(arr[1], source, options) : resolveResult(arr[2], source, options);
         }
         else {
             // [ifTruthy, thenResult] — guard, skip if falsy
-            return resolved ? resolveTernaryValue(arr[1], source, options) : TERNARY_SKIP;
+            return resolved ? resolveResult(arr[1], source, options) : TERNARY_SKIP;
         }
     }
 }
+/**
+ * Evaluate a chain shortcut: [c1, '||', c2, ...] or [c1, '??', c2, ...].
+ *
+ * - '||' returns the first truthy candidate (JS `c1 || c2 || c3`).
+ * - '??' returns the first non-nullish candidate (JS `c1 ?? c2 ?? c3`).
+ *
+ * Candidates sit at even indices and are resolved lazily — evaluation stops
+ * at the first match. What happens when no candidate passes depends on the
+ * trailing element:
+ * - Ends with a candidate ([c1, '||', c2]): the last candidate doubles as the
+ *   fallback (returned even when it fails the test, matching JS semantics).
+ * - Ends with a non-marker element after the last candidate ([c1, '||', c2, fb]):
+ *   that element is the explicit fallback.
+ * - Ends with a dangling marker ([c1, '||'] or [c1, '||', c2, '||']): guard form —
+ *   nothing to assign (TERNARY_SKIP).
+ *
+ * Mixing marker types in one chain is not supported; the first marker sets the mode.
+ *
+ * Candidates may themselves be nested ternaries (see resolveResult). A nested
+ * guard that skips counts as a failed candidate — the chain continues; if it
+ * was the final fallback, the skip propagates.
+ */
+function evaluateChain(arr, source, options) {
+    const isNullish = arr[1] === '??';
+    const n = arr.length;
+    const endsWithMarker = arr[n - 1] === '||' || arr[n - 1] === '??';
+    const lastCandidateIdx = n - (endsWithMarker || n % 2 === 0 ? 2 : 1);
+    let lastVal;
+    for (let i = 0; i <= lastCandidateIdx; i += 2) {
+        lastVal = resolveResult(arr[i], source, options);
+        if (lastVal === TERNARY_SKIP)
+            continue; // nested guard skipped — try next candidate
+        const pass = isNullish ? lastVal != null : !!lastVal;
+        if (pass)
+            return lastVal;
+    }
+    if (endsWithMarker)
+        return TERNARY_SKIP;
+    // Odd count: last candidate doubles as fallback. Even count: explicit trailing fallback.
+    return n % 2 === 1 ? lastVal : resolveResult(arr[n - 1], source, options);
+}
 /**
  * Compare two values with a given operator.
  */

package/assignFrom.ts

@@ -79,6 +79,30 @@ function resolveTernaryValue(value: any, source: any, options: AssignFromOptions
     return value;
 }
 
+/**
+ * Check if a value in a result position is a nested ternary expression.
+ * Trigger: an array of length ≥ 2 whose first element is a `?.`-prefixed
+ * string (truthiness mode) or an array (comparison mode). Other arrays
+ * are treated as literal values.
+ */
+function isNestedTernary(value: any): boolean {
+    if (!Array.isArray(value) || value.length < 2) return false;
+    const first = value[0];
+    return Array.isArray(first) || (typeof first === 'string' && first.startsWith('?.'));
+}
+
+/**
+ * Resolve a value in a result position (then/else/neither, comparison results,
+ * chain candidates). Nested ternary expressions are evaluated recursively;
+ * everything else goes through resolveTernaryValue.
+ */
+function resolveResult(value: any, source: any, options: AssignFromOptions): any {
+    if (isNestedTernary(value)) {
+        return evaluateTernary(value, source, options);
+    }
+    return resolveTernaryValue(value, source, options);
+}
+
 /**
  * Evaluate a ?= ternary expression.
  * 
@@ -88,8 +112,12 @@ function resolveTernaryValue(value: any, source: any, options: AssignFromOptions
  * - [ifTrue, trueResult, falseResult, neither]     — three-state (true/false/nullish)
  * - [[lhs, rhs], ifEqual, ifNotEqual?]             — equality comparison
  * - [[lhs, rhs], ifEqual]                          — equality guard
+ * - [c1, '||', c2, '||', c3, ...]                  — first truthy candidate (c1 || c2 || c3)
+ * - [c1, '??', c2, '??', c3, ...]                  — first non-nullish candidate (c1 ?? c2 ?? c3)
+ * - [c1, t1, [c2, t2, e2]]                         — nested ternary in any result position
  * 
- * Returns undefined to signal "skip assignment" (guard forms when condition not met).
+ * Returns TERNARY_SKIP to signal "skip assignment" (guard forms when condition
+ * not met). A skip from a nested guard propagates outward.
  */
 const TERNARY_SKIP = Symbol('ternary-skip');
 
@@ -103,9 +131,9 @@ function evaluateTernary(arr: any[], source: any, options: AssignFromOptions): a
             // Equality: [[lhs, rhs], result, elseResult?]
             const rhs = resolveTernaryValue(condition[1], source, options);
             if (lhs === rhs) {
-                return resolveTernaryValue(arr[1], source, options);
+                return resolveResult(arr[1], source, options);
             } else {
-                return arr.length > 2 ? resolveTernaryValue(arr[2], source, options) : TERNARY_SKIP;
+                return arr.length > 2 ? resolveResult(arr[2], source, options) : TERNARY_SKIP;
             }
         } else {
             // Operator: [[lhs, op, rhs], result, elseResult?]
@@ -113,28 +141,73 @@ function evaluateTernary(arr: any[], source: any, options: AssignFromOptions): a
             const rhs = resolveTernaryValue(condition[2], source, options);
             const satisfied = compareWithOp(lhs, op, rhs);
             if (satisfied) {
-                return resolveTernaryValue(arr[1], source, options);
+                return resolveResult(arr[1], source, options);
             } else {
-                return arr.length > 2 ? resolveTernaryValue(arr[2], source, options) : TERNARY_SKIP;
+                return arr.length > 2 ? resolveResult(arr[2], source, options) : TERNARY_SKIP;
             }
         }
     } else {
+        // Chain shortcut: [c1, '||', c2, ...] or [c1, '??', c2, ...]
+        // Checked before the length-based dispatch so a length-4 chain
+        // isn't misread as the three-state form.
+        if (arr[1] === '||' || arr[1] === '??') {
+            return evaluateChain(arr, source, options);
+        }
         // Truthiness mode
         const resolved = resolveTernaryValue(condition, source, options);
         if (arr.length === 4) {
             // [ifTrue, trueResult, falseResult, neitherResult]
-            if (resolved == null) return resolveTernaryValue(arr[3], source, options);
-            return resolved ? resolveTernaryValue(arr[1], source, options) : resolveTernaryValue(arr[2], source, options);
+            if (resolved == null) return resolveResult(arr[3], source, options);
+            return resolved ? resolveResult(arr[1], source, options) : resolveResult(arr[2], source, options);
         } else if (arr.length === 3) {
             // [ifTruthy, thenResult, elseResult]
-            return resolved ? resolveTernaryValue(arr[1], source, options) : resolveTernaryValue(arr[2], source, options);
+            return resolved ? resolveResult(arr[1], source, options) : resolveResult(arr[2], source, options);
         } else {
             // [ifTruthy, thenResult] — guard, skip if falsy
-            return resolved ? resolveTernaryValue(arr[1], source, options) : TERNARY_SKIP;
+            return resolved ? resolveResult(arr[1], source, options) : TERNARY_SKIP;
         }
     }
 }
 
+/**
+ * Evaluate a chain shortcut: [c1, '||', c2, ...] or [c1, '??', c2, ...].
+ *
+ * - '||' returns the first truthy candidate (JS `c1 || c2 || c3`).
+ * - '??' returns the first non-nullish candidate (JS `c1 ?? c2 ?? c3`).
+ *
+ * Candidates sit at even indices and are resolved lazily — evaluation stops
+ * at the first match. What happens when no candidate passes depends on the
+ * trailing element:
+ * - Ends with a candidate ([c1, '||', c2]): the last candidate doubles as the
+ *   fallback (returned even when it fails the test, matching JS semantics).
+ * - Ends with a non-marker element after the last candidate ([c1, '||', c2, fb]):
+ *   that element is the explicit fallback.
+ * - Ends with a dangling marker ([c1, '||'] or [c1, '||', c2, '||']): guard form —
+ *   nothing to assign (TERNARY_SKIP).
+ *
+ * Mixing marker types in one chain is not supported; the first marker sets the mode.
+ *
+ * Candidates may themselves be nested ternaries (see resolveResult). A nested
+ * guard that skips counts as a failed candidate — the chain continues; if it
+ * was the final fallback, the skip propagates.
+ */
+function evaluateChain(arr: any[], source: any, options: AssignFromOptions): any {
+    const isNullish = arr[1] === '??';
+    const n = arr.length;
+    const endsWithMarker = arr[n - 1] === '||' || arr[n - 1] === '??';
+    const lastCandidateIdx = n - (endsWithMarker || n % 2 === 0 ? 2 : 1);
+    let lastVal: any;
+    for (let i = 0; i <= lastCandidateIdx; i += 2) {
+        lastVal = resolveResult(arr[i], source, options);
+        if (lastVal === TERNARY_SKIP) continue; // nested guard skipped — try next candidate
+        const pass = isNullish ? lastVal != null : !!lastVal;
+        if (pass) return lastVal;
+    }
+    if (endsWithMarker) return TERNARY_SKIP;
+    // Odd count: last candidate doubles as fallback. Even count: explicit trailing fallback.
+    return n % 2 === 1 ? lastVal : resolveResult(arr[n - 1], source, options);
+}
+
 /**
  * Compare two values with a given operator.
  */

package/assignFromAsync.ts

@@ -20,7 +20,8 @@
  * // target is now { color: 'red', text: 'Hello' }
  */
 import { resolveValues } from './resolveValues.js';
-import assignGingerly, { IAssignGingerlyOptions } from './assignGingerly.js';
+import {IAssignGingerlyOptions} from './types/assign-gingerly/types.js';
+import assignGingerly from './assignGingerly.js';
 import type { AssignPermissions } from './isAllowedImportPath.js';
 import type { AssignFromHandler, AssignFromHandlerConstructor } from './types/assign-gingerly/types.js';
 import {

package/assignGingerly.js

@@ -571,9 +571,9 @@ export function assignGingerly(target, source, options, permissions) {
         : undefined;
     const registry = options?.registry instanceof EnhancementRegistry
         ? options.registry
-        : options?.registry
-            ? new options.registry()
-            : undefined;
+        // : options?.registry
+        // ? new options.registry()
+        : undefined;
     // Convert Symbol.for string keys to actual symbols and apply aliases
     const processedSource = {};
     for (const key of Object.keys(source)) {
@@ -653,6 +653,7 @@ export function assignGingerly(target, source, options, permissions) {
                         lhsParent = ensureNestedPath(target, pathParts);
                         lhsValue = lhsParent[lhsKey];
                     }
+                    //TODO:  this logic seems to occur twice at least.  Maybe make it a method?
                     // 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;

package/assignGingerly.ts

@@ -1,7 +1,7 @@
 
 
 import { EnhancementConfig } from "./types/assign-gingerly/types";
-import type { FeatureConfigsMap } from "./types/assign-gingerly/types";
+import type { AssignFromOptions, FeatureConfigsMap, IAssignGingerlyOptions } from "./types/assign-gingerly/types";
 import type { AssignPermissions } from "./isAllowedImportPath.js";
 import { normalizeAliasOptions } from './getValues.js';
 
@@ -32,113 +32,6 @@ export interface ItemscopeManagerConfig<T = any> {
   };
 }
 
-/**
- * Interface for the options passed to assignGingerly
- */
-export interface IAssignGingerlyOptions {
-  registry?: typeof EnhancementRegistry | EnhancementRegistry;
-  bypassChecks?: boolean;
-  
-  /**
-   * List of property names that should be treated as methods to call
-   * rather than properties to assign.
-   * 
-   * When a path segment matches a name in this array/set:
-   * - If the property is a function, call it with appropriate arguments
-   * - For the last segment: use RHS value as argument (spread if array)
-   * - For middle segments: use next segment as string argument (if next is not also a method)
-   * - If consecutive segments are both methods, first is called with no arguments
-   * - If the property is not a function, silently skip
-   * 
-   * Example:
-   * assignGingerly(element, {
-   *   '?.classList?.add': 'myClass'
-   * }, { withMethods: ['add'] });
-   * // Calls: element.classList.add('myClass')
-   * 
-   * Chained methods:
-   * assignGingerly(elementRef, {
-   *   '?.deref?.querySelector?.myElement?.classList?.add': 'active'
-   * }, { withMethods: ['deref', 'querySelector', 'add'] });
-   * // Calls: elementRef.deref().querySelector('myElement').classList.add('active')
-   */
-  withMethods?: string[] | Set<string>;
-  
-  /**
-   * Alias mappings for property and method names.
-   * Allows shorter, customizable shortcuts in path expressions.
-   * 
-   * Aliases are substituted before path evaluation, matching complete tokens
-   * between `?.` delimiters (not substrings).
-   * 
-   * Reserved characters (cannot be used in aliases): space, backtick (`)
-   * 
-   * Example:
-   * assignGingerly(element, {
-   *   '?.$?.my-element?.c?.+': 'highlighted'
-   * }, { 
-   *   withMethods: ['querySelector', 'add'],
-   *   aka: { '$': 'querySelector', 'c': 'classList', '+': 'add' }
-   * });
-   * // Equivalent to: element.querySelector('my-element').classList.add('highlighted')
-   */
-  aka?: Record<string, string>;
-
-  /**
-   * Shorthand for binding method aliases from the source object.
-   * Each entry maps an alias to a method name, and is normalized into
-   * the existing withMethods + aka behavior.
-   */
-  akaMethods?: Record<string, string>;
-  
-  /**
-   * AbortSignal for cleaning up reactive subscriptions (@eachTime)
-   * Required when using @eachTime symbol for reactive iteration
-   * When the signal is aborted, all event listeners are automatically removed
-   * 
-   * Example:
-   * const controller = new AbortController();
-   * assignGingerly(div, {
-   *   '?.mountObserver?.@eachTime?.classList?.add': 'highlighted'
-   * }, { 
-   *   withMethods: ['add'],
-   *   signal: controller.signal
-   * });
-   * // Later: controller.abort(); // Cleanup all listeners
-   */
-  signal?: AbortSignal;
-
-  /**
-   * List of property names that should be treated as async methods.
-   * Works together with withMethods — async methods are awaited before
-   * continuing the chain.
-   * 
-   * The path evaluation for keys containing async methods is fire-and-forget:
-   * assignGingerly remains synchronous and returns immediately. The async
-   * chain completes in the background.
-   * 
-   * NOTE: Interaction with @each and @eachTime is not yet implemented.
-   * 
-   * Example:
-   * assignGingerly(el, {
-   *   '?.whenFeatureReady?.photoTaker?.someProp': 'hello'
-   * }, { withAsyncMethods: ['whenFeatureReady'] });
-   * // Calls: (await el.whenFeatureReady('photoTaker')).someProp = 'hello'
-   */
-  withAsyncMethods?: string[] | Set<string>;
-
-  /**
-   * Bulk enhancement application via EMC JSON configs.
-   * Finds matching elements and spawns enhancements on them.
-   * Fire-and-forget (async) — assignGingerly remains synchronous.
-   * 
-   * @example
-   * enhance: [
-   *     { emc: 'be-bound/emc.json', matching: '[name]' },
-   * ]
-   */
-  enhance?: Array<{ emc: string; matching?: string; parse?: boolean }>;
-}
 
 /**
  * GUID for global instance map storage to ensure uniqueness across package versions
@@ -779,8 +672,8 @@ export function assignGingerly(
 
   const registry = options?.registry instanceof EnhancementRegistry
     ? options.registry
-    : options?.registry
-    ? new options.registry()
+    // : options?.registry
+    // ? new options.registry()
     : undefined;
 
   // Convert Symbol.for string keys to actual symbols and apply aliases
@@ -867,12 +760,13 @@ export function assignGingerly(
             lhsValue = lhsParent[lhsKey];
           }
 
+          //TODO:  this logic seems to occur twice at least.  Maybe make it a method?
           // 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;
+            const capturedOptions = options as AssignFromOptions | undefined;
             import('./handlers/addEventListener.js').then(({ attachEventListener }) => {
               attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {});
             });
@@ -898,7 +792,7 @@ export function assignGingerly(
             const capturedLhs = target[path];
             const capturedValue = value;
             const capturedTarget = target;
-            const capturedOptions = options;
+            const capturedOptions = options as AssignFromOptions | undefined;
             import('./handlers/addEventListener.js').then(({ attachEventListener }) => {
               attachEventListener(capturedLhs, capturedValue, capturedTarget, capturedOptions?.from ?? capturedTarget, capturedOptions ?? {});
             });

package/eachTime.ts

@@ -4,7 +4,7 @@
  * Provides event-driven iteration over elements as they mount
  */
 
-import type { IAssignGingerlyOptions } from './assignGingerly.js';
+import type { IAssignGingerlyOptions } from './types/assign-gingerly/types.js';
 
 /**
  * Check if a value is an EventTarget

package/handleIshProperty.ts

@@ -1,4 +1,4 @@
-import type { IAssignGingerlyOptions, ItemscopeManagerConfig } from './assignGingerly.js';
+import type { IAssignGingerlyOptions } from './types/assign-gingerly/types.js';
 
 /**
  * Handle the 'ish' property assignment for HTMLElements with itemscope attributes.

package/inferencer/types/assign-gingerly/types.d.ts

@@ -272,6 +272,37 @@ export interface IAssignGingerlyOptions {
    * When the signal is aborted, all event listeners are automatically removed
    */
   signal?: AbortSignal;
+
+  /**
+   * List of property names that should be treated as async methods.
+   * Works together with withMethods — async methods are awaited before
+   * continuing the chain.
+   * 
+   * The path evaluation for keys containing async methods is fire-and-forget:
+   * assignGingerly remains synchronous and returns immediately. The async
+   * chain completes in the background.
+   * 
+   * NOTE: Interaction with @each and @eachTime is not yet implemented.
+   * 
+   * Example:
+   * assignGingerly(el, {
+   *   '?.whenFeatureReady?.photoTaker?.someProp': 'hello'
+   * }, { withAsyncMethods: ['whenFeatureReady'] });
+   * // Calls: (await el.whenFeatureReady('photoTaker')).someProp = 'hello'
+   */
+  withAsyncMethods?: string[] | Set<string>;
+
+    /**
+   * Bulk enhancement application via EMC JSON configs.
+   * Finds matching elements and spawns enhancements on them.
+   * Fire-and-forget (async) — assignGingerly remains synchronous.
+   * 
+   * @example
+   * enhance: [
+   *     { emc: 'be-bound/emc.json', matching: '[name]' },
+   * ]
+   */
+  enhance?: Array<{ emc: string; matching?: string; parse?: boolean }>;
 }
 
 /**

package/object-extension.ts

@@ -1,4 +1,5 @@
-import assignGingerly, { EnhancementRegistry, ItemscopeRegistry, IAssignGingerlyOptions, getInstanceMap, INSTANCE_MAP_GUID } from './assignGingerly.js';
+import assignGingerly, { EnhancementRegistry, ItemscopeRegistry,  getInstanceMap } from './assignGingerly.js';
+import {IAssignGingerlyOptions,} from './types/assign-gingerly/types.js';
 import assignTentatively from './assignTentatively.js';
 import type { IAssignTentativelyOptions } from './types/assign-gingerly/types.js';
 import { EnhancementConfig, SpawnContext } from './types/assign-gingerly/types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assign-gingerly",
-  "version": "0.0.69",
+  "version": "0.0.71",
   "description": "This package provides a utility function for carefully merging one object into another.",
   "homepage": "https://github.com/bahrus/assign-gingerly#readme",
   "bugs": {
@@ -111,6 +111,26 @@
       "default": "./handlers/manageTemplateList.js",
       "types": "./handlers/manageTemplateList.ts"
     },
+    "./handlers/nudge.js": {
+      "default": "./handlers/nudge.js",
+      "types": "./handlers/nudge.ts"
+    },
+    "./handlers/arr.js": {
+      "default": "./handlers/arr.js",
+      "types": "./handlers/arr.ts"
+    },
+    "./inferencer/inferencer.js": {
+      "default": "./inferencer/inferencer.js",
+      "types": "./inferencer/inferencer.ts"
+    },
+    "./inferencer/upSearch.js": {
+      "default": "./inferencer/upSearch.js",
+      "types": "./inferencer/upSearch.ts"
+    },
+    "./inferencer/withScopePerimeter.js": {
+      "default": "./inferencer/withScopePerimeter.js",
+      "types": "./inferencer/withScopePerimeter.ts"
+    },
     "./DX/paths.js": {
       "default": "./DX/paths.js",
       "types": "./DX/paths.ts"
@@ -143,14 +163,6 @@
       "default": "./beVigilant.js",
       "types": "./beVigilant.ts"
     },
-    "./inferencer/inferencer.js": {
-      "default": "./inferencer/inferencer.js",
-      "types": "./inferencer/inferencer.ts"
-    },
-    "./inferencer/withScopePerimeter.js": {
-      "default": "./inferencer/withScopePerimeter.js",
-      "types": "./inferencer/withScopePerimeter.ts"
-    },
     "./assignFromAsync.js": {
       "default": "./assignFromAsync.js",
       "types": "./assignFromAsync.ts"
@@ -178,14 +190,6 @@
     "./evaluatePathWithAsyncMethods.js": {
       "default": "./evaluatePathWithAsyncMethods.js",
       "types": "./evaluatePathWithAsyncMethods.ts"
-    },
-    "./handlers/nudge.js": {
-      "default": "./handlers/nudge.js",
-      "types": "./handlers/nudge.ts"
-    },
-    "./handlers/arr.js": {
-      "default": "./handlers/arr.js",
-      "types": "./handlers/arr.ts"
     }
   },
   "main": "index.js",

package/types/assign-gingerly/types.d.ts

@@ -272,6 +272,37 @@ export interface IAssignGingerlyOptions {
    * When the signal is aborted, all event listeners are automatically removed
    */
   signal?: AbortSignal;
+
+  /**
+   * List of property names that should be treated as async methods.
+   * Works together with withMethods — async methods are awaited before
+   * continuing the chain.
+   * 
+   * The path evaluation for keys containing async methods is fire-and-forget:
+   * assignGingerly remains synchronous and returns immediately. The async
+   * chain completes in the background.
+   * 
+   * NOTE: Interaction with @each and @eachTime is not yet implemented.
+   * 
+   * Example:
+   * assignGingerly(el, {
+   *   '?.whenFeatureReady?.photoTaker?.someProp': 'hello'
+   * }, { withAsyncMethods: ['whenFeatureReady'] });
+   * // Calls: (await el.whenFeatureReady('photoTaker')).someProp = 'hello'
+   */
+  withAsyncMethods?: string[] | Set<string>;
+
+    /**
+   * Bulk enhancement application via EMC JSON configs.
+   * Finds matching elements and spawns enhancements on them.
+   * Fire-and-forget (async) — assignGingerly remains synchronous.
+   * 
+   * @example
+   * enhance: [
+   *     { emc: 'be-bound/emc.json', matching: '[name]' },
+   * ]
+   */
+  enhance?: Array<{ emc: string; matching?: string; parse?: boolean }>;
 }
 
 /**