assign-gingerly 0.0.64 → 0.0.66

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.
@@ -775,7 +816,7 @@ While we are in the business of passing values of object A into object B, we mig
 
 | Operator | Name | Description | Example |
 |----------|------|-------------|---------|
-| ` +=` | Increment | Add to numeric value, concatenate strings, append to arrays | `'count +=': 5` |
+| ` +=` | Increment | Add to numeric, concat strings, append to arrays, or [bind events](docs/event-binding.md) | `'count +=': 5` |
 | ` =!` | Toggle | Negate a boolean (or any value via `!`) | `'visible =!': '.'` |
 | ` -=` | Delete | Remove properties from an object | `'?.data -=': 'key'` |
 | ` Y=` | Merge | Recursively `assignGingerly` into a sub-object | `'style Y=': { width: '100px' }` |
@@ -816,6 +857,8 @@ The `+=` command syntax is `<path> +=` where the path uses the `?.` nested notat
 | LHS type | RHS type | Result |
 |----------|----------|--------|
 | number | number | addition (`2 += 3` → `5`) |
+| number | string (numeric) | parse + addition (`5 += '3'` → `8`) |
+| number | string (non-numeric) | string concatenation (`5 += 'px'` → `'5px'`) |
 | string | any | string concatenation (`"hello" += 3` → `"hello3"`) |
 | array | array | array concatenation (`[1,2] += [3,4]` → `[1,2,3,4]`) |
 | array | non-array | push single item (`[1,2] += 3` → `[1,2,3]`) |
@@ -835,6 +878,22 @@ assignGingerly(obj, {
 assignGingerly(obj, { '?.tags +=': 'e' }); // ['a', 'b', 'c', 'd', 'e']
 ```
 
+**Event binding with `+=`:**
+
+When the LHS resolves to a DOM Element and the RHS is an object with an `on` property, `+=` attaches a declarative event listener:
+
+```JavaScript
+assignFrom(this.shadowRoot, {
+    '?.querySelector?.button +=': {
+        on: 'click',
+        '?.isHappy =!': '.',                    // toggle host property
+        fromLHS: { '?.age +=': '?.dataset.diff' } // read from button, assign to host
+    }
+}, { from: this, withMethods: ['querySelector'] });
+```
+
+The handler is lazy-loaded on demand. For full details including assignment vectors, dedup, nudge, and custom event dispatch, see [docs/event-binding.md](docs/event-binding.md).
+
 ## Example 5 - Toggling boolean values and negating
 
 The `=!` command allows us to toggle boolean values:
@@ -3859,7 +3918,7 @@ await assignFromAsync(container, {
             if: '?.showPanel',
             instantiate: 'globalThis://panelTemplate',
             assign: {
-                assignToFragment: {
+                toClone: {
                     '#[title]?.textContent': '?.panelTitle',
                     '#[body]?.textContent': '?.panelContent'
                 },
@@ -3872,7 +3931,7 @@ await assignFromAsync(container, {
 }, { from: vm, withMethods: ['querySelector'], protocols: { globalThis: k => globalThis[k] } });
 ```
 
-The `assign.assignToFragment` paths resolve against `options.from` (the same source that drives the `if` condition). For multi-element templates, use `assign.configs` (same zip semantics as `manageTemplateList`).
+The `assign.toClone` paths resolve against `options.from` (the same source that drives the `if` condition). For multi-element templates, use `assign.configs` (same zip semantics as `manageTemplateList`).
 
 ### View Transitions
 
@@ -4189,7 +4248,7 @@ assignFrom(document.body, {
             instantiate: 'globalThis://country-ranking',
         },
         fromEachItem: {
-            assignToFragment: { '?.querySelector?.tr?.ish': '?.' },
+            toClone: { '?.querySelector?.tr?.ish': '?.' },
             withOptions: { withMethods: ['querySelector'], infer: true },
             get: { key: '?.rank' }
         }
@@ -4205,7 +4264,7 @@ assignFrom(document.body, {
 
 1. Resolves `forEach` (iterable) and `instantiate` (template) from the `resolve` block
 2. Clones the template once per item, buffering all clones into a `DocumentFragment`
-3. For each clone, calls `assignFrom(clone, assignToFragment, { from: item, ...withOptions })` — distributing the item's data
+3. For each clone, calls `assignFrom(clone, toClone, { from: item, ...withOptions })` — distributing the item's data
 4. Inserts the fragment between comment markers in one DOM operation
 5. On subsequent calls, reconciles by `key` — adds new items, removes missing ones, updates existing clones in place
 
@@ -4218,13 +4277,13 @@ The `key` field (in `fromEachItem.get`) identifies each item for stable identity
 
 Without `key`, positional matching is used (item[i] → clone[i]).
 
-**Shared parent data (`fromSource`):**
+**Shared parent data (`fromHost`):**
 
 Pass data from the outer VM into each clone (e.g., aggregate totals):
 
 ```JavaScript
-fromSource: {
-    assignToFragment: {
+fromHost: {
+    toClone: {
         '?.querySelector?.[part~="totalMedalCount"]?.textContent': '?.totalMedalCount'
     },
     withOptions: { withMethods: ['querySelector'] }
@@ -4387,7 +4446,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 +4461,7 @@ await assignFromAsync(document.body, {
     }
 }, {
     from: viewModel,
-    withIds: {
+    pin: {
         main: { qry: '.mainView' }  // find by class, auto-assign ID, cache
     }
 });
@@ -4416,12 +4475,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 +4510,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 +4540,7 @@ assignFrom(document.body, {
 }, {
     from: viewModel,
     withMethods: ['querySelector'],
-    withIds: {
+    pin: {
         form: { qry: '.registration-form' },
         header: 'page-header'
     }
@@ -4498,7 +4557,7 @@ await assignFromAsync(container, {
     }
 }, {
     from: router,
-    withIds: { outlet: { qry: '.router-outlet' } },
+    pin: { outlet: { qry: '.router-outlet' } },
     protocols: { globalThis: k => globalThis[k] }
 });
 ```
@@ -4511,7 +4570,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 +4583,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;
+    const { withMethods, aka, akaMethods, protocols, from } = options;
     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 }, from, { withMethods, aka, akaMethods, 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 }, from, { withMethods, aka, akaMethods, 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 };
 }
 
 /**
@@ -320,6 +322,7 @@ function processIdRefNormalKeys(
   const ids = getEffectiveIds(options);
   if (!ids) return;
 
+  const { withMethods, aka, akaMethods, protocols, from } = options;
   for (const key of idRefNormalKeys) {
     const parsed = parseIdRef(key);
     if (!parsed) continue;
@@ -330,15 +333,15 @@ function processIdRefNormalKeys(
     const value = expandedPattern[key];
     if (parsed.remainingPath) {
       const resolvedValue = getValues(
-        { __v: value }, options.from,
-        { withMethods: options.withMethods, aka: options.aka, protocols: options.protocols }
+        { __v: value }, from,
+        { withMethods, aka, akaMethods, 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 }
+        from,
+        { withMethods, aka, akaMethods, protocols, root: target }
       );
       if (!('__v' in resolvedValue)) {
         assignGingerly(el, resolvedValue, options);
@@ -371,6 +374,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 +384,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 +397,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 +412,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 +425,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 +444,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');
+        const { withMethods, aka, akaMethods, protocols, from } = options;
         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 }, from, { withMethods, aka, akaMethods, 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 }, from, { withMethods, aka, akaMethods, 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) {