@neocompose/cli 0.24.6 → 0.24.7

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.24.7] - 2026-08-08
+
+### Fixed
+
+- Lower named delegate method groups such as `this.SelectTorso` to the P60
+  member-target wire form, then bind their receiver to each constructed
+  instance. Constructor-pane previews now retain that binding when replacing
+  the evaluator's provisional root, so animation tracks resolve against the
+  ephemeral preview graph instead of disappearing.
+- Reconstruct stored inline-closure `this` from the nearest compatible lexical
+  owner in nested declaration graphs, keeping closures distinct from named
+  method groups as required by P60.
+
 ## [0.24.6] - 2026-08-08
 
 ### Fixed

package/dist/neo.mjs

@@ -10058,7 +10058,7 @@ var init_strict_resolver = __esm({
         }
         return void 0;
       }
-      resolveDelegateMethodGroup(expression, expected, scope) {
+      resolveDelegateMethodGroup(expression, expected, scope, options = {}) {
         let symbol;
         let receiver = null;
         let owner;
@@ -10133,29 +10133,17 @@ var init_strict_resolver = __esm({
             expression.pos
           );
         }
-        const parameters = expected.parameterTypes.map(
-          (type, index) => variable(`__arg_${index}__`, type, void 0, this.project)
+        if (receiver?.kind === "instance" && options.allowUnboundInstanceTarget !== true && (receiver.expression.pointer.type !== "variable" /* Variable */ || receiver.expression.pointer.variableId !== this.thisVariable.id)) {
+          throw new CompileError(
+            "NeoDelegate method groups currently require the current 'this' receiver.",
+            expression.pos
+          );
+        }
+        return literal(
+          expected,
+          { memberId: symbol.id, valueId: null },
+          this.project
         );
-        const call = {
-          type: "callFunction" /* CallFunction */,
-          memberId: symbol.id,
-          receiver: receiver?.kind === "static" ? { kind: "static", memberId: receiver.memberId } : {
-            kind: "instance",
-            pointer: receiver?.expression.pointer ?? this.thisVariable.pointer
-          },
-          args: parameters.map((parameter4) => ({
-            type: "variable" /* Variable */,
-            variableId: parameter4.id
-          })),
-          callSiteId: this.nextCallSite(expression.pos)
-        };
-        const action = {
-          compilerRevision: NEOSCRIPT_COMPILER_REVISION,
-          parameters: [this.thisVariable, this.rootVariable, ...parameters],
-          instructions: expectedVoid ? [{ type: "functionCall" /* FunctionCall */, call }] : [{ type: "return" /* Return */, pointer: call }],
-          typeInfo: expectedVoid ? toWireType({ kind: "primitive", name: "null" }, this.project) : toWireType(expected.returnType, this.project)
-        };
-        return literal(expected, { action }, this.project);
       }
       /** Derives the exact expected delegate signature for a test mock target. */
       inferDelegateMethodGroupType(expression, scope) {
@@ -11830,7 +11818,10 @@ var init_strict_resolver = __esm({
           const target = this.resolveDelegateMethodGroup(
             targetAst,
             delegateType,
-            scope
+            scope,
+            // Mock targets are member-identity metadata. They are never invoked as
+            // delegates, and mockHandle.on(receiver) owns receiver scoping.
+            { allowUnboundInstanceTarget: true }
           );
           if (target === null) {
             throw new CompileError(
@@ -42238,6 +42229,7 @@ function evaluateLiteralContainer(args) {
   }
   return {
     literal: literal2,
+    ...evaluated.provisionalRootId === void 0 ? {} : { provisionalRootId: evaluated.provisionalRootId },
     ...evaluated.existingValueRow === void 0 ? {} : { existingValueRow: evaluated.existingValueRow }
   };
 }
@@ -42259,6 +42251,13 @@ function buildDefaultMemberValue(args) {
       return evaluated.existingValueRow;
     }
     const value2 = buildNewValue(args.projectId, evaluated.literal);
+    if (evaluated.provisionalRootId !== void 0) {
+      retargetDelegateReceiverValueIds(
+        [value2, ...args.createdValues],
+        evaluated.provisionalRootId,
+        value2.id
+      );
+    }
     args.createdValues.push(value2);
     recordStorageKeyDeclaration(args.storageKeyDeclarations, value2.id, member);
     return value2;
@@ -42465,6 +42464,28 @@ function buildNewValue(projectId, body) {
   };
   return props;
 }
+function retargetDelegateReceiverValueIds(rows, fromValueId, toValueId) {
+  const visited = /* @__PURE__ */ new WeakSet();
+  const visit = (value) => {
+    if (typeof value !== "object" || value === null) return;
+    if (visited.has(value)) return;
+    visited.add(value);
+    if (isMemberDelegateTarget(value)) {
+      if (value.valueId === fromValueId) value.valueId = toValueId;
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const entry of value) visit(entry);
+      return;
+    }
+    for (const entry of Object.values(value)) visit(entry);
+  };
+  for (const row of rows) {
+    if (!isLiteralValueContent(row)) continue;
+    visit(row.value);
+    visit(row.constructorArgs);
+  }
+}
 function cloneDefaultClassRecord(args) {
   const sourceValue = args.sourceBody?.value;
   if (!isStringRecord(sourceValue)) return {};
@@ -42601,6 +42622,13 @@ function cloneDefaultValueForMember(args) {
       return evaluated.existingValueRow;
     }
     const evaluatedRow = buildNewValue(args.projectId, evaluated.literal);
+    if (evaluated.provisionalRootId !== void 0) {
+      retargetDelegateReceiverValueIds(
+        [evaluatedRow, ...args.createdValues],
+        evaluated.provisionalRootId,
+        evaluatedRow.id
+      );
+    }
     evaluatedRow.sourceValueId = sourceValue.sourceValueId ?? args.sourceValueId;
     args.createdValues.push(evaluatedRow);
     recordStorageKeyDeclaration(
@@ -58794,10 +58822,16 @@ function evalPointer(pointer, scope, ctx) {
       if (isNSDelegateClosureValue(value)) {
         return {
           ...value,
-          [DELEGATE_LEXICAL_THIS]: ctx.thisValue,
+          ...ctx.thisValue === null || ctx.thisValue === void 0 ? {} : { [DELEGATE_LEXICAL_THIS]: ctx.thisValue },
           [DELEGATE_LEXICAL_ROOT]: ctx.rootValue
         };
       }
+      if (isMemberDelegateTarget(value) && value.valueId === null) {
+        const member = evalMemberById(ctx.vm, value.memberId);
+        if (member === null || member.isStatic === true) return value;
+        const receiver = trackedRowForValueReference(ctx.thisValue, ctx);
+        return receiver === null ? value : { ...value, valueId: receiver.id };
+      }
       return value;
     }
     case "variable" /* variable */: {
@@ -59173,50 +59207,49 @@ function delegateClosureLexicalThis(closure, ctx) {
   if (Object.prototype.hasOwnProperty.call(closure, DELEGATE_LEXICAL_THIS)) {
     return closure[DELEGATE_LEXICAL_THIS];
   }
+  const lexicalThisType = closure.action.parameters[0]?.typeInfo;
+  if (lexicalThisType === void 0 || lexicalThisType.type === NS_TYPE_UNKNOWN || lexicalThisType.type === 0 /* Null */) {
+    return null;
+  }
   const closureRow = trackedRowForValueReference(closure, ctx);
   if (closureRow === null) {
     throw new NSGetterRuntimeError(
       "Stored NeoDelegate closure has no resolvable value row; lexical this cannot be reconstructed from ownership."
     );
   }
-  const owners = /* @__PURE__ */ new Map();
-  for (const link of evaluatorParentLinks(
-    evaluatorIndexes(ctx),
-    closureRow.id
+  const owners = [];
+  const indexes = evaluatorIndexes(ctx);
+  for (const [ancestorId, distance] of evaluatorOwnershipDistances(
+    closureRow.id,
+    indexes
   )) {
-    const parent = evalValueById(
+    if (ancestorId === closureRow.id) continue;
+    const ancestor = evalValueById(
       ctx.vm,
-      link.parentId,
+      ancestorId,
       ctx.__runtimeSessionValues,
       ctx.__valueOverlay
     );
-    if (parent === null) continue;
-    if (typeof parent.value !== "object") continue;
-    if (parent.value === null) continue;
-    if (Array.isArray(parent.value)) continue;
-    const classId = classIdForValueRow(parent, ctx);
-    if (classId === void 0) continue;
-    const owningMember = memberForCustomSchemaValue(classId, link.key, ctx);
-    if (owningMember?.kind !== 25 /* NSDelegate */) continue;
-    owners.set(parent.id, parent.value);
+    if (ancestor === null) continue;
+    if (typeof ancestor.value !== "object") continue;
+    if (ancestor.value === null || Array.isArray(ancestor.value)) continue;
+    if (!runtimeValueMatchesType(ancestor.value, lexicalThisType, ctx))
+      continue;
+    owners.push({ id: ancestor.id, value: ancestor.value, distance });
   }
-  if (owners.size === 0) {
+  if (owners.length === 0) {
     throw new NSGetterRuntimeError(
       `Stored NeoDelegate closure value '${closureRow.id}' has no owning class instance; lexical this cannot be reconstructed from ownership.`
     );
   }
-  if (owners.size > 1) {
-    throw new NSGetterRuntimeError(
-      `Stored NeoDelegate closure value '${closureRow.id}' has multiple owning class instances (${[...owners.keys()].join(", ")}); lexical this is ambiguous.`
-    );
-  }
-  const owner = owners.values().next();
-  if (owner.done) {
+  const nearestDistance = Math.min(...owners.map((owner) => owner.distance));
+  const nearest = owners.filter((owner) => owner.distance === nearestDistance);
+  if (nearest.length > 1) {
     throw new NSGetterRuntimeError(
-      `Stored NeoDelegate closure value '${closureRow.id}' lost its owning class instance during lexical-this resolution.`
+      `Stored NeoDelegate closure value '${closureRow.id}' has multiple owning class instances (${nearest.map((owner) => owner.id).join(", ")}); lexical this is ambiguous.`
     );
   }
-  return owner.value;
+  return nearest[0].value;
 }
 function resolveCallableSignature(memberId, memberKind, ctx) {
   const cacheKey = `${memberKind}:${memberId}`;
@@ -61097,6 +61130,74 @@ function stageConstructedRows(createdValues, ctx) {
     if (ctx.__indexes !== void 0) indexEvaluatorRow(ctx.__indexes, row);
   }
 }
+function bindConstructedDelegateTargets(rootId, ctx) {
+  const indexes = evaluatorIndexes(ctx);
+  const pending = [rootId];
+  const visited = /* @__PURE__ */ new Set();
+  while (pending.length > 0) {
+    const rowId = pending.pop();
+    if (rowId === void 0 || visited.has(rowId)) continue;
+    visited.add(rowId);
+    const row = evalValueById(
+      ctx.vm,
+      rowId,
+      ctx.__runtimeSessionValues,
+      ctx.__valueOverlay
+    );
+    if (row === null) continue;
+    if (Array.isArray(row.value)) {
+      for (const childId of row.value) {
+        if (typeof childId === "string") pending.push(childId);
+      }
+    } else if (typeof row.value === "object" && row.value !== null) {
+      for (const childId of Object.values(row.value)) {
+        if (typeof childId === "string") pending.push(childId);
+      }
+    }
+    if (!isMemberDelegateTarget(row.value) || row.value.valueId !== null) {
+      continue;
+    }
+    const target = evalMemberById(ctx.vm, row.value.memberId);
+    if (target === null || target.isStatic === true) continue;
+    const placement = findSchemaPlacement(target.id, ctx.vm.classes);
+    if (placement === null) {
+      throw new NSGetterRuntimeError(
+        `NeoDelegate method target '${target.name}' has no declaring Class placement.`
+      );
+    }
+    const matches = [];
+    for (const [ancestorId, distance] of evaluatorOwnershipDistances(
+      row.id,
+      indexes
+    )) {
+      const ancestor = evalValueById(
+        ctx.vm,
+        ancestorId,
+        ctx.__runtimeSessionValues,
+        ctx.__valueOverlay
+      );
+      if (ancestor === null) continue;
+      const ancestorClassId = classIdForValueRow(ancestor, ctx);
+      if (ancestorClassId === void 0) continue;
+      const ownsTarget = resolveInheritanceChain(
+        ancestorClassId,
+        ctx.vm.classes
+      ).some((schemaClass2) => schemaClass2.id === placement.ownerClass.id);
+      if (ownsTarget) matches.push({ id: ancestor.id, distance });
+    }
+    if (matches.length === 0) continue;
+    const nearestDistance = Math.min(...matches.map((match) => match.distance));
+    const nearest = matches.filter(
+      (match) => match.distance === nearestDistance
+    );
+    if (nearest.length !== 1) {
+      throw new NSGetterRuntimeError(
+        `NeoDelegate method target '${target.name}' has multiple equally near receiver instances (${nearest.map((match) => match.id).join(", ")}).`
+      );
+    }
+    row.value = { ...row.value, valueId: nearest[0].id };
+  }
+}
 function publishConstructedRows(args) {
   const { root, createdValues, ctx } = args;
   assertConstructorRowsHaveSingleStructuralOwner(createdValues, ctx);
@@ -61158,6 +61259,7 @@ function publishConstructedRows(args) {
     destination.set(row.id, row);
     if (ctx.__indexes !== void 0) indexEvaluatorRow(ctx.__indexes, row);
   }
+  bindConstructedDelegateTargets(root.id, ctx);
   state.constructorGroups.set(root.id, retained);
   state.ownedValueAttachments.clear();
 }
@@ -61855,6 +61957,7 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
   return {
     value: result.value,
     classId: rootRow.classId ?? null,
+    provisionalRootId: rootRow.id,
     ...constructorArgs === void 0 ? {} : { constructorArgs: structuredClone(constructorArgs) }
   };
 }
@@ -62146,6 +62249,7 @@ function constructDeclaredClassValueWithinFrame(descriptor, record3, info, scope
     root.constructorArgs = structuredClone(encoded);
   }
   stageConstructedRows(createdValues, ctx);
+  bindConstructedDelegateTargets(root.id, ctx);
   if (record3 !== null) {
     runDeclaredConstructorChain({
       record: record3,
@@ -63430,6 +63534,7 @@ function evaluateMemberInitializer(args) {
   return {
     value: result.value,
     classId: rootRow.classId ?? null,
+    provisionalRootId: rootRow.id,
     ...constructorArgs === void 0 ? {} : { constructorArgs: structuredClone(constructorArgs) }
   };
 }
@@ -63490,6 +63595,13 @@ function materializeInitializerValue(args) {
     ...evaluated.classId === null ? {} : { classId: evaluated.classId },
     ...evaluated.constructorArgs === void 0 ? {} : { constructorArgs: structuredClone(evaluated.constructorArgs) }
   };
+  if (evaluated.provisionalRootId !== void 0) {
+    retargetDelegateReceiverValueIds(
+      [root, ...createdValues],
+      evaluated.provisionalRootId,
+      root.id
+    );
+  }
   const allCreated = [root, ...createdValues];
   for (const created of createdValues) {
     if (created.classId === void 0) delete created.classId;
@@ -88472,13 +88584,15 @@ function lowerFunctionReference(context, expression, ownerClassId) {
   return { functionMemberId: target.id };
 }
 function lowerDelegateValue(context, expression, ownerClassId, authoredSlice) {
-  const code = initializerExpressionSlice(authoredSlice);
-  if (code === void 0) {
-    throw new Error(
-      "Delegate values require recoverable authored source so the server can compile their lexical receiver."
-    );
+  if (expression.kind === "lambda") {
+    const code = initializerExpressionSlice(authoredSlice);
+    if (code === void 0) {
+      throw new Error(
+        "Delegate lambdas require recoverable authored source so the server can compile their closure."
+      );
+    }
+    return { code };
   }
-  if (expression.kind === "lambda") return { code };
   const path = memberPath(expression);
   const symbol = path?.startsWith("this.") ? path.slice("this.".length) : path;
   if (symbol === null || symbol === void 0 || symbol.includes(".")) {
@@ -88497,7 +88611,7 @@ function lowerDelegateValue(context, expression, ownerClassId, authoredSlice) {
       `Delegate ${symbol} does not resolve to a function, NSFunction, or NSDelegate member.`
     );
   }
-  return { code };
+  return { memberId: target.id, valueId: null };
 }
 function fileTargetId(context, expression, registry) {
   const path = memberPath(expression);
@@ -101546,7 +101660,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.9",
-      cliVersion: "0.24.6",
+      cliVersion: "0.24.7",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -102951,21 +103065,7 @@ function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function findDelegateTargetMemberId(value) {
-  if (!isRecord10(value) || !isRecord10(value.action)) return null;
-  const pending = [value.action.instructions];
-  while (pending.length > 0) {
-    const current = pending.shift();
-    if (Array.isArray(current)) {
-      pending.push(...current);
-      continue;
-    }
-    if (!isRecord10(current)) continue;
-    if (current.type === "callFunction" && typeof current.memberId === "string") {
-      return current.memberId;
-    }
-    pending.push(...Object.values(current));
-  }
-  return null;
+  return isRecord10(value) && typeof value.memberId === "string" ? value.memberId : null;
 }
 function makeEvaluatorContext(rawDocument, interceptor, documentAlreadyIsolated = false) {
   const isolatedDocument = documentAlreadyIsolated ? rawDocument : structuredClone(rawDocument);
@@ -104081,7 +104181,7 @@ async function runTest(workspace, options, dependencies = {}) {
       cliVersion: PROJECT_SCHEMA_CONTRACT.cliVersion,
       runnerRevision: 3,
       compilerRevision: NEOSCRIPT_COMPILER_REVISION,
-      evaluatorRevision: 3,
+      evaluatorRevision: 4,
       projectFingerprint,
       configurationSha256: createHash10("sha256").update(JSON.stringify(workspace.config.test ?? {})).digest("hex"),
       dependencyGraph: Object.fromEntries(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.24.6",
+  "version": "0.24.7",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.24.6 -->
+<!-- reviewed-through-cli: 0.24.7 -->
 
 # Neo Compose CLI
 

package/skills/neocompose-cli/references/animation-and-world-authoring.md

@@ -181,9 +181,11 @@ pulled rows.
 A selector argument such as `this.SelectPants` is evaluated in the lexical
 scope of the class that declares the clip. Here `this` is the `LegPart`, not
 the nested track row or an outer object instance that later receives a copy of
-the declaration default. Keep that named method group as authored delegate
-source through lowering so construction can capture each concrete `LegPart`;
-an unbound member target has no instance on which to invoke the selector.
+the declaration default. A named method group lowers to the P60 member-target
+form. Its declaration default carries `valueId: null` because no instance row
+exists yet; materializing the declaration binds it to the concrete `LegPart`
+row. An inline closure remains compiled closure source and reconstructs its
+lexical owner from the materialized graph. Do not interchange these two forms.
 
 Each track has `StartFrame`, `Direction` (`.Forward` or `.Reverse`), and a
 crop window `OffsetStartIndex`/`OffsetEndIndex`. Crop before reversing, then

package/skills/neocompose-cli/references/cli-development.md

@@ -82,7 +82,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.24.6 -->
+<!-- reviewed-through-cli: 0.24.7 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale