assign-gingerly 0.0.64 → 0.0.65

package/README.md

@@ -94,10 +94,24 @@ For most use cases — including `manageTemplateList`, reactive merge cycles, an
 assignFrom adds support for:
 
 1.  Resolving RHS path strings against a source object (`from`).
-2.  Protocol resolution (`globalThis://`, `localStorage://`, custom sync protocols).
-3.  Handler plugins via the ` =>` operator for custom logic (fire-and-forget in sync mode, awaitable in async mode).
-4.  Looped substitution with `where_x_in` / `where_y_in` / `where_z_in` for expanding template patterns into multiple concrete assignments.
-5.  Spread merging via the `"..."` key.
+2.  Target-relative root references via `$0` so paths can resolve from the first argument passed to `assignFrom`/`assignFromAsync` (the target object) instead of the `from` object.
+3.  Protocol resolution (`globalThis://`, `localStorage://`, custom sync protocols).
+4.  Handler plugins via the ` =>` operator for custom logic (fire-and-forget in sync mode, awaitable in async mode).
+5.  Looped substitution with `where_x_in` / `where_y_in` / `where_z_in` for expanding template patterns into multiple concrete assignments.
+6.  Spread merging via the `"..."` key.
+
+Example:
+
+```TypeScript
+const target = { value: 'target-value' };
+const source = { value: 'from-value' };
+
+assignFrom(target, {
+  resolved: '$0?.value'
+}, { from: source });
+
+console.log(target.resolved); // 'target-value'
+```
 
 All of assignGingerly's features (nested paths, `withMethods`, `aka`, `@each`, `@eachTime`, registry, etc.) are inherited.
 
@@ -476,11 +490,11 @@ assignGingerly(div, {
 
 // With aliases (concise)
 assignGingerly(div, {
-  '?.$?.my-element?.c?.+': 'highlighted',
-  '?.$?.your-element?.c?.+': 'active'
+  '?.🔍?.my-element?.🎨?.+': 'highlighted',
+  '?.🔍?.your-element?.🎨?.+': 'active'
 }, { 
   withMethods: ['querySelector', 'add'],
-  aka: { '$': 'querySelector', 'c': 'classList', '+': 'add' }
+  aka: { '🔍': 'querySelector', '🎨': 'classList', '+': 'add' }
 });
 ```
 
@@ -536,6 +550,33 @@ assignGingerly(element, {
 - Improves readability when you have many similar operations
 - Works seamlessly with `withMethods`
 
+**Shorthand for method aliases:**
+
+If you frequently pair aliases with method calls, you can use `akaMethods` as a compact alternative to passing both `withMethods` and `aka` separately. Each entry in `akaMethods` maps an alias to the method name that should be treated as a callable method:
+
+```TypeScript
+const div = document.createElement('div');
+
+div.innerHTML = `
+  <my-element></my-element>
+`;
+
+assignGingerly(div, {
+  '?.🔍?.my-element?.🎨?.+': 'highlighted'
+}, {
+  akaMethods: {
+    '🔍': 'querySelector',
+    '🎨': 'classList',
+    '+': 'add'
+  }
+});
+
+const myElement = div.querySelector('my-element');
+console.log(myElement?.classList.contains('highlighted')); // true
+```
+
+`akaMethods` is additive: it complements the existing `withMethods` and `aka` options rather than replacing them.
+
 ## Example 3e - ForEach with @each
 
 The `@each` symbol allows you to iterate over collections and apply operations to each item. This works with any iterable including Arrays, NodeList, HTMLCollection, and more.
@@ -4387,7 +4428,7 @@ md`${$.firstName} ${{ prop: 'birthDate', val: $.birthDT, format: 'long' }}`
 
 Both auto-detect path proxies (no `.path` needed inside template literals) and preserve nested arrays for optional segments.
 
-## Cached Element Resolution with `#[x]` and `withIds`
+## Cached Element Resolution with `#[x]` and `pin`
 
 `assignFrom` supports cached element references via the `#[x]` syntax in LHS keys. This provides near-zero-cost repeated access to DOM elements (~10ns via WeakRef) instead of expensive `querySelector` calls (~3,000-17,000ns for class selectors at scale).
 
@@ -4402,7 +4443,7 @@ await assignFromAsync(document.body, {
     }
 }, {
     from: viewModel,
-    withIds: {
+    pin: {
         main: { qry: '.mainView' }  // find by class, auto-assign ID, cache
     }
 });
@@ -4416,12 +4457,12 @@ await assignFromAsync(document.body, {
 4. On subsequent calls, the cached `WeakRef.deref()` returns the element in ~10ns.
 5. If the WeakRef is collected (element was GC'd), falls back to `getElementById` (~10-100ns).
 
-**`withIds` — stable references with auto-assigned IDs:**
+**`pin` — stable references with auto-assigned IDs:**
 
 All forms assign a unique ID to the resolved element (if it doesn't have one). This makes the reference resilient to future DOM mutations — once an element has an ID, it can be found regardless of structural changes.
 
 ```TypeScript
-withIds: {
+pin: {
     x: { qry: '.mainView' },    // querySelector on target, auto-assign ID
     y: 'existingId',             // element already has an ID, cache via WeakRef
     z: { path: [0, 1], expect: 'input', fallback: true },  // child index path + auto-ID + validation
@@ -4451,14 +4492,14 @@ at: {
 - You want a clean DOM (no auto-generated `id` attributes)
 - You're rendering many items (1,000 rows × 2 refs = 2,000 fewer DOM attributes)
 
-Both `withIds` and `at` use the same `#[x]` syntax on LHS and RHS keys.
+Both `pin` and `at` use the same `#[x]` syntax on LHS and RHS keys.
 
 **Validated paths with `expect` and `fallback`:**
 
-Both `withIds` and `at` support the `{ path, expect, fallback }` form for dev-time validation:
+Both `pin` and `at` support the `{ path, expect, fallback }` form for dev-time validation:
 
 ```TypeScript
-withIds: {
+pin: {
     nameInput: { path: [1], expect: 'input' },              // warn if [1] isn't an <input>
     label:     { path: [0], expect: 'label', fallback: true } // warn + recover via querySelector
 }
@@ -4481,7 +4522,7 @@ assignFrom(document.body, {
 }, {
     from: viewModel,
     withMethods: ['querySelector'],
-    withIds: {
+    pin: {
         form: { qry: '.registration-form' },
         header: 'page-header'
     }
@@ -4498,7 +4539,7 @@ await assignFromAsync(container, {
     }
 }, {
     from: router,
-    withIds: { outlet: { qry: '.router-outlet' } },
+    pin: { outlet: { qry: '.router-outlet' } },
     protocols: { globalThis: k => globalThis[k] }
 });
 ```
@@ -4511,7 +4552,7 @@ await assignFromAsync(container, {
 | `getElementById(id)` | 100ns | 20ns | 10ns |
 | `Map<id, WeakRef>.deref()` | 12ns | 40ns | 10ns |
 
-The `#[x]` + `withIds` pattern gives you the Map+WeakRef speed tier automatically.
+The `#[x]` + `pin` pattern gives you the Map+WeakRef speed tier automatically.
 
 **RHS references (`#[x]` on the value side):**
 
@@ -4524,7 +4565,7 @@ assignFrom(form, {
     '?.headerText': '#[info]?.dataset?.user',                    // → nested property access
 }, {
     from: {},
-    withIds: { nameInput: { qry: 'input' }, info: { qry: '.info' } },
+    pin: { nameInput: { qry: 'input' }, info: { qry: '.info' } },
     withMethods: ['querySelector']
 });
 ```

package/assignFrom.js

@@ -49,7 +49,8 @@ function resolveTernaryValue(value, source, options) {
         return getValue(value, source, {
             withMethods: options.withMethods,
             aka: options.aka,
-            protocols: options.protocols
+            protocols: options.protocols,
+            root: options.root
         });
     }
     if (typeof value === 'string' && value.includes('://') && options.protocols) {
@@ -60,7 +61,8 @@ function resolveTernaryValue(value, source, options) {
             return getValue(value, source, {
                 withMethods: options.withMethods,
                 aka: options.aka,
-                protocols: options.protocols
+                protocols: options.protocols,
+                root: options.root
             });
         }
     }
@@ -287,16 +289,16 @@ export function categorizeKeys(expandedPattern) {
     return { handlerKeys, normalPattern, idRefNormalKeys, idRefHandlerKeys, ternaryKeys };
 }
 /**
- * Merge withIds and at into a single lookup map for resolveIdVariable.
+ * Merge pin and at into a single lookup map for resolveIdVariable.
  */
 function getEffectiveIds(options) {
-    if (!options.withIds && !options.at)
+    if (!options.pin && !options.at)
         return undefined;
-    if (options.withIds && !options.at)
-        return options.withIds;
-    if (!options.withIds && options.at)
+    if (options.pin && !options.at)
+        return options.pin;
+    if (!options.pin && options.at)
         return options.at;
-    return { ...options.withIds, ...options.at };
+    return { ...options.pin, ...options.at };
 }
 /**
  * Process #[x] normal keys synchronously.
@@ -305,6 +307,7 @@ function processIdRefNormalKeys(idRefNormalKeys, expandedPattern, target, option
     const ids = getEffectiveIds(options);
     if (!ids)
         return;
+    //TODO
     for (const key of idRefNormalKeys) {
         const parsed = parseIdRef(key);
         if (!parsed)
@@ -314,11 +317,11 @@ function processIdRefNormalKeys(idRefNormalKeys, expandedPattern, target, option
             continue;
         const value = expandedPattern[key];
         if (parsed.remainingPath) {
-            const resolvedValue = getValues({ __v: value }, options.from, { withMethods: options.withMethods, aka: options.aka, protocols: options.protocols });
+            const resolvedValue = getValues({ __v: value }, options.from, { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: target });
             assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options);
         }
         else {
-            const resolvedValue = getValues(typeof value === 'object' && value !== null ? value : { __v: value }, options.from, { withMethods: options.withMethods, aka: options.aka, protocols: options.protocols });
+            const resolvedValue = getValues(typeof value === 'object' && value !== null ? value : { __v: value }, options.from, { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: target });
             if (!('__v' in resolvedValue)) {
                 assignGingerly(el, resolvedValue, options);
             }
@@ -342,6 +345,7 @@ export function assignFrom(target, pattern, options, permissions) {
     const expandedPattern = expandSubstitutions(pattern, options);
     // Categorize keys
     const { handlerKeys, normalPattern, idRefNormalKeys, idRefHandlerKeys, ternaryKeys } = categorizeKeys(expandedPattern);
+    const resolveOptions = { ...options, root: target };
     // Process ?= ternary keys (sync)
     if (ternaryKeys.length > 0) {
         const ternaryResolved = {};
@@ -352,7 +356,7 @@ export function assignFrom(target, pattern, options, permissions) {
             const arr = expandedPattern[key];
             if (!Array.isArray(arr) || arr.length < 2)
                 continue;
-            const result = evaluateTernary(arr, options.from, options);
+            const result = evaluateTernary(arr, options.from, resolveOptions);
             if (result !== TERNARY_SKIP) {
                 ternaryResolved[lhsPath] = result;
             }
@@ -364,7 +368,7 @@ export function assignFrom(target, pattern, options, permissions) {
     // Process normal keys via getValues (sync) + assignGingerly
     if (Object.keys(normalPattern).length > 0) {
         // Resolve #[x] references on RHS values before getValues
-        if (options.withIds || options.at) {
+        if (options.pin || options.at) {
             const ids = getEffectiveIds(options);
             for (const key of Object.keys(normalPattern)) {
                 const value = normalPattern[key];
@@ -379,7 +383,9 @@ export function assignFrom(target, pattern, options, permissions) {
                                 normalPattern[key] = getValue(remainingPath, el, {
                                     withMethods: options.withMethods,
                                     aka: options.aka,
-                                    protocols: options.protocols
+                                    akaMethods: options.akaMethods,
+                                    protocols: options.protocols,
+                                    root: target
                                 });
                             }
                             else {
@@ -390,11 +396,7 @@ export function assignFrom(target, pattern, options, permissions) {
                 }
             }
         }
-        const resolved = getValues(normalPattern, options.from, {
-            withMethods: options.withMethods,
-            aka: options.aka,
-            protocols: options.protocols
-        });
+        const resolved = getValues(normalPattern, options.from, resolveOptions);
         handleSpreads(resolved);
         assignGingerly(target, resolved, options);
     }
@@ -409,7 +411,7 @@ export function assignFrom(target, pattern, options, permissions) {
         });
     }
     // Process #[x] handler keys — fire-and-forget (async)
-    if (idRefHandlerKeys.length > 0 && (options.withIds || options.at)) {
+    if (idRefHandlerKeys.length > 0 && (options.pin || options.at)) {
         const ids = getEffectiveIds(options);
         import('./processHandlerCommands.js').then(({ processHandlerCommands }) => {
             for (const key of idRefHandlerKeys) {

package/assignFrom.ts

@@ -10,14 +10,14 @@
  */
 
 import { getValues, getValue } from './getValues.js';
-import assignGingerly, { IAssignGingerlyOptions } from './assignGingerly.js';
+import assignGingerly from './assignGingerly.js';
 import { resolveIdVariable, parseIdRef } from './resolveIdRef.js';
 import { processInferredAssignments } from './inferredAssignments.js';
 import type { AssignPermissions } from './isAllowedImportPath.js';
+import type { AssignFromOptions, AssignFromHandler, AssignFromHandlerConstructor } from './types/assign-gingerly/types.js';
 
-// Re-export types and interfaces for consumers
-export type { AssignFromOptions, AssignFromHandler, AssignFromHandlerConstructor } from './assignFromAsync.js';
-import type { AssignFromOptions } from './assignFromAsync.js';
+// Re-export types for consumers
+export type { AssignFromOptions, AssignFromHandler, AssignFromHandlerConstructor };
 
 /**
  * Supported substitution variables and their option keys.
@@ -54,12 +54,13 @@ export function parseTernaryCommand(key: string): string | null {
  * Resolve a single value — if it's a `?.` path string, resolve against source.
  * If it's a protocol string, resolve via protocol. Otherwise pass through as literal.
  */
-function resolveTernaryValue(value: any, source: any, options: AssignFromOptions): any {
+function resolveTernaryValue(value: any, source: any, options: AssignFromOptions | any): any {
     if (typeof value === 'string' && value.startsWith('?.')) {
         return getValue(value, source, {
             withMethods: options.withMethods,
             aka: options.aka,
-            protocols: options.protocols
+            protocols: options.protocols,
+            root: options.root
         });
     }
     if (typeof value === 'string' && value.includes('://') && options.protocols) {
@@ -70,7 +71,8 @@ function resolveTernaryValue(value: any, source: any, options: AssignFromOptions
             return getValue(value, source, {
                 withMethods: options.withMethods,
                 aka: options.aka,
-                protocols: options.protocols
+                protocols: options.protocols,
+                root: options.root
             });
         }
     }
@@ -299,13 +301,13 @@ export function categorizeKeys(expandedPattern: Record<string, any>) {
 }
 
 /**
- * Merge withIds and at into a single lookup map for resolveIdVariable.
+ * Merge pin and at into a single lookup map for resolveIdVariable.
  */
 function getEffectiveIds(options: AssignFromOptions): Record<string, any> | undefined {
-  if (!options.withIds && !options.at) return undefined;
-  if (options.withIds && !options.at) return options.withIds;
-  if (!options.withIds && options.at) return options.at;
-  return { ...options.withIds, ...options.at };
+  if (!options.pin && !options.at) return undefined;
+  if (options.pin && !options.at) return options.pin;
+  if (!options.pin && options.at) return options.at;
+  return { ...options.pin, ...options.at };
 }
 
 /**
@@ -319,7 +321,7 @@ function processIdRefNormalKeys(
 ): void {
   const ids = getEffectiveIds(options);
   if (!ids) return;
-
+  //TODO
   for (const key of idRefNormalKeys) {
     const parsed = parseIdRef(key);
     if (!parsed) continue;
@@ -331,14 +333,14 @@ function processIdRefNormalKeys(
     if (parsed.remainingPath) {
       const resolvedValue = getValues(
         { __v: value }, options.from,
-        { withMethods: options.withMethods, aka: options.aka, protocols: options.protocols }
+        { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: target }
       );
       assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options);
     } else {
       const resolvedValue = getValues(
         typeof value === 'object' && value !== null ? value : { __v: value },
         options.from,
-        { withMethods: options.withMethods, aka: options.aka, protocols: options.protocols }
+        { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: target }
       );
       if (!('__v' in resolvedValue)) {
         assignGingerly(el, resolvedValue, options);
@@ -371,6 +373,8 @@ export function assignFrom(
   // Categorize keys
   const { handlerKeys, normalPattern, idRefNormalKeys, idRefHandlerKeys, ternaryKeys } = categorizeKeys(expandedPattern);
 
+  const resolveOptions = { ...options, root: target } as any;
+
   // Process ?= ternary keys (sync)
   if (ternaryKeys.length > 0) {
     const ternaryResolved: Record<string, any> = {};
@@ -379,7 +383,7 @@ export function assignFrom(
       if (!lhsPath) continue;
       const arr = expandedPattern[key];
       if (!Array.isArray(arr) || arr.length < 2) continue;
-      const result = evaluateTernary(arr, options.from, options);
+      const result = evaluateTernary(arr, options.from, resolveOptions);
       if (result !== TERNARY_SKIP) {
         ternaryResolved[lhsPath] = result;
       }
@@ -392,7 +396,7 @@ export function assignFrom(
   // Process normal keys via getValues (sync) + assignGingerly
   if (Object.keys(normalPattern).length > 0) {
     // Resolve #[x] references on RHS values before getValues
-    if (options.withIds || options.at) {
+    if (options.pin || options.at) {
       const ids = getEffectiveIds(options)!;
       for (const key of Object.keys(normalPattern)) {
         const value = normalPattern[key];
@@ -407,7 +411,9 @@ export function assignFrom(
                 normalPattern[key] = getValue(remainingPath, el, {
                   withMethods: options.withMethods,
                   aka: options.aka,
-                  protocols: options.protocols
+                  akaMethods: options.akaMethods,
+                  protocols: options.protocols,
+                  root: target
                 });
               } else {
                 normalPattern[key] = el.id; // bare #[x] → ID string
@@ -418,11 +424,7 @@ export function assignFrom(
       }
     }
 
-    const resolved = getValues(normalPattern, options.from, {
-      withMethods: options.withMethods,
-      aka: options.aka,
-      protocols: options.protocols
-    });
+    const resolved = getValues(normalPattern, options.from, resolveOptions);
 
     handleSpreads(resolved);
     assignGingerly(target, resolved, options);
@@ -441,7 +443,7 @@ export function assignFrom(
   }
 
   // Process #[x] handler keys — fire-and-forget (async)
-  if (idRefHandlerKeys.length > 0 && (options.withIds || options.at)) {
+  if (idRefHandlerKeys.length > 0 && (options.pin || options.at)) {
     const ids = getEffectiveIds(options)!;
     import('./processHandlerCommands.js').then(({ processHandlerCommands }) => {
       for (const key of idRefHandlerKeys) {

package/assignFromAsync.js

@@ -34,16 +34,19 @@ export async function assignFromAsync(target, pattern, options, permissions) {
         const resolved = await resolveValues(normalPattern, options.from, {
             withMethods: options.withMethods,
             aka: options.aka,
-            protocols: options.protocols
+            akaMethods: options.akaMethods,
+            protocols: options.protocols,
+            root: target
         });
         // Recursively handle "..." spread keys at all nesting levels
         handleSpreads(resolved);
         assignGingerly(target, resolved, options);
     }
     // Process #[x] normal keys — resolve element, then apply remaining path + value
-    if (idRefNormalKeys.length > 0 && (options.withIds || options.at)) {
-        const ids = { ...options.withIds, ...options.at };
+    if (idRefNormalKeys.length > 0 && (options.pin || options.at)) {
+        const ids = { ...options.pin, ...options.at };
         const { resolveIdVariable, parseIdRef } = await import('./resolveIdRef.js');
+        //TODO
         for (const key of idRefNormalKeys) {
             const parsed = parseIdRef(key);
             if (!parsed)
@@ -54,13 +57,13 @@ export async function assignFromAsync(target, pattern, options, permissions) {
             const value = expandedPattern[key];
             if (parsed.remainingPath) {
                 // Resolve the RHS value
-                const resolvedValue = await resolveValues({ __v: value }, options.from, { withMethods: options.withMethods, aka: options.aka, protocols: options.protocols });
+                const resolvedValue = await resolveValues({ __v: value }, options.from, { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: el });
                 // Apply remaining path on the resolved element
                 assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options);
             }
             else {
                 // No remaining path — resolve and assign directly to the element
-                const resolvedValue = await resolveValues(typeof value === 'object' && value !== null ? value : { __v: value }, options.from, { withMethods: options.withMethods, aka: options.aka, protocols: options.protocols });
+                const resolvedValue = await resolveValues(typeof value === 'object' && value !== null ? value : { __v: value }, options.from, { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: el });
                 if ('__v' in resolvedValue) {
                     // Single value — can't assign to element root without a path
                 }
@@ -76,8 +79,8 @@ export async function assignFromAsync(target, pattern, options, permissions) {
         await _processHandlerCommands(target, handlerKeys, expandedPattern, options, permissions);
     }
     // Process #[x] handler keys — resolve element, then pass to handler processing
-    if (idRefHandlerKeys.length > 0 && (options.withIds || options.at)) {
-        const ids = { ...options.withIds, ...options.at };
+    if (idRefHandlerKeys.length > 0 && (options.pin || options.at)) {
+        const ids = { ...options.pin, ...options.at };
         const { resolveIdVariable, parseIdRef } = await import('./resolveIdRef.js');
         _processHandlerCommands ??= (await import('./processHandlerCommands.js')).processHandlerCommands;
         for (const key of idRefHandlerKeys) {

package/assignFromAsync.ts

@@ -22,117 +22,31 @@
 import { resolveValues } from './resolveValues.js';
 import assignGingerly, { IAssignGingerlyOptions } from './assignGingerly.js';
 import type { AssignPermissions } from './isAllowedImportPath.js';
+import type { AssignFromHandler, AssignFromHandlerConstructor } from './types/assign-gingerly/types.js';
 import {
   expandSubstitutions, categorizeKeys, handleSpreads, isHandlerCommand
 } from './assignFrom.js';
 
 export interface AssignFromOptions extends IAssignGingerlyOptions {
-  /** Source object to resolve RHS path strings against */
   from: any;
-
-  /** Protocol handlers (sync or async) */
   protocols?: Record<string, (key: string) => any | Promise<any>>;
-
-  /** Loop variable bindings — expand pattern entries containing ${x} */
   where_x_in?: string[];
-  /** Loop variable bindings — expand pattern entries containing ${y} */
   where_y_in?: string[];
-  /** Loop variable bindings — expand pattern entries containing ${z} */
   where_z_in?: string[];
-
-  /**
-   * Cached element references by variable name.
-   * Used with `#[varName]` syntax in LHS keys for fast repeated element access.
-   * 
-   * - String value: existing element ID (uses getElementById)
-   * - Object value: { qry: 'selector' } — finds element via querySelector on target, auto-assigns an ID
-   * 
-   * Elements are cached via WeakRef with getElementById fallback on cache miss.
-   */
-  withIds?: Record<string, string | { qry: string }>;
-
-  /**
-   * Positional element references for use with `#[varName]` syntax.
-   * Resolves elements by child index path — no IDs assigned, no caching.
-   * 
-   * - Array value: child index path (e.g., [0, 1] = target.children[0].children[1])
-   * - Object value: { path: [...], expect?: 'selector', fallback?: true }
-   *   expect: validates via element.matches(), logs correction if wrong
-   *   fallback: on mismatch, recovers via querySelector(expect)
-   */
+  pin?: Record<string, string | { qry: string } | { path: number[]; expect?: string; fallback?: boolean }>;
   at?: Record<string, number[] | { path: number[]; expect?: string; fallback?: boolean }>;
-
-  /**
-   * Handler implementations scoped to this call.
-   * Key: the `do` name referenced in handler configs.
-   * Value: a class constructor, or an import path to dynamically load one.
-   * 
-   * Import paths must be local (relative, absolute, or bare specifier — no cross-domain URLs).
-   * The module's default export is checked first; otherwise the first exported class
-   * with an `assign` method on its prototype is used.
-   * 
-   * Built-in handlers (builtIns.*) auto-load without needing to be listed here.
-   * 
-   * @example
-   * handlers: {
-   *     'my-list': MyListHandler,                    // class constructor
-   *     'my-chart': './handlers/chart.js',           // dynamic import path
-   *     'vendor-widget': 'some-package/handler.js',  // bare specifier (import map)
-   * }
-   */
   handlers?: Record<string, AssignFromHandlerConstructor | string>;
-
-  /**
-   * Inferred assignments — automatically distribute source values to matching
-   * DOM elements based on structural conventions (itemprop, name, etc.).
-   * 
-   * Uses the inferencer submodule to determine the correct property for each
-   * matched element (textContent, value, checked, dateTime, ish, etc.).
-   * 
-   * @example
-   * infer: {
-   *     byItemprop: ['user', 'name', 'email'],  // or true for all source keys
-   *     beVigilant: true,  // watch for new matching elements (requires signal)
-   * }
-   */
   infer?: {
     byItemprop?: string[] | true;
     '|'?: string[] | true;
     byName?: string[] | true | { props: string[] | true; outside: string };
     '@'?: string[] | true | { props: string[] | true; outside: string };
-    /** Watch for new matching elements via MutationObserver. Requires options.signal for cleanup. */
     beVigilant?: boolean;
   };
-
-  /**
-   * Bulk enhancement application via EMC JSON configs.
-   * Finds matching elements and spawns enhancements on them.
-   * 
-   * Each entry specifies an EMC JSON path and optionally overrides the matching selector.
-   * Enhancements are auto-registered if not already present in the enhancement registry.
-   * 
-   * No scope perimeter is applied — use mount-observer for reactive/scoped enhancement.
-   * 
-   * @example
-   * enhance: [
-   *     { emc: 'be-bound/emc.json', matching: '[name]' },
-   *     { emc: 'be-observant/emc.json', matching: '[itemprop]' },
-   * ]
-   */
   enhance?: Array<{ emc: string; matching?: string; parse?: boolean }>;
 }
 
-/**
- * Interface for assignFrom handler classes.
- * Handlers are invoked when a LHS key ends with ' =>'.
- */
-export interface AssignFromHandler {
-    assign(lhsTarget: any, resolvedParams: Record<string, any>, options: AssignFromOptions): Promise<void> | void;
-}
-
-export interface AssignFromHandlerConstructor {
-    new (config: any): AssignFromHandler;
-}
+export type { AssignFromHandler, AssignFromHandlerConstructor };
 
 // Module cache for processHandlerCommands — avoids await on dynamic import after first call
 let _processHandlerCommands: any;
@@ -154,7 +68,9 @@ export async function assignFromAsync(
     const resolved = await resolveValues(normalPattern, options.from, {
       withMethods: options.withMethods,
       aka: options.aka,
-      protocols: options.protocols
+      akaMethods: options.akaMethods,
+      protocols: options.protocols,
+      root: target
     });
 
     // Recursively handle "..." spread keys at all nesting levels
@@ -164,9 +80,10 @@ export async function assignFromAsync(
   }
 
   // Process #[x] normal keys — resolve element, then apply remaining path + value
-  if (idRefNormalKeys.length > 0 && (options.withIds || options.at)) {
-    const ids = { ...options.withIds, ...options.at };
+  if (idRefNormalKeys.length > 0 && (options.pin || options.at)) {
+    const ids = { ...options.pin, ...options.at };
     const { resolveIdVariable, parseIdRef } = await import('./resolveIdRef.js');
+    //TODO
     for (const key of idRefNormalKeys) {
       const parsed = parseIdRef(key);
       if (!parsed) continue;
@@ -179,7 +96,7 @@ export async function assignFromAsync(
         // Resolve the RHS value
         const resolvedValue = await resolveValues(
           { __v: value }, options.from,
-          { withMethods: options.withMethods, aka: options.aka, protocols: options.protocols }
+          { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: el }
         );
         // Apply remaining path on the resolved element
         assignGingerly(el, { [parsed.remainingPath]: resolvedValue.__v }, options);
@@ -188,7 +105,7 @@ export async function assignFromAsync(
         const resolvedValue = await resolveValues(
           typeof value === 'object' && value !== null ? value : { __v: value },
           options.from,
-          { withMethods: options.withMethods, aka: options.aka, protocols: options.protocols }
+          { withMethods: options.withMethods, aka: options.aka, akaMethods: options.akaMethods, protocols: options.protocols, root: el }
         );
         if ('__v' in resolvedValue) {
           // Single value — can't assign to element root without a path
@@ -205,8 +122,8 @@ export async function assignFromAsync(
     await _processHandlerCommands(target, handlerKeys, expandedPattern, options, permissions);
   }
   // Process #[x] handler keys — resolve element, then pass to handler processing
-  if (idRefHandlerKeys.length > 0 && (options.withIds || options.at)) {
-    const ids = { ...options.withIds, ...options.at };
+  if (idRefHandlerKeys.length > 0 && (options.pin || options.at)) {
+    const ids = { ...options.pin, ...options.at };
     const { resolveIdVariable, parseIdRef } = await import('./resolveIdRef.js');
     _processHandlerCommands ??= (await import('./processHandlerCommands.js')).processHandlerCommands;