@neocompose/cli 0.24.9 → 0.25.1

package/dist/neo.mjs

@@ -1291,6 +1291,7 @@ var init_language_spec = __esm({
       "Partial",
       "FunctionRef",
       "NeoDelegate",
+      "NeoAction",
       "Dialogue",
       "Trigger",
       "Node",
@@ -1958,6 +1959,12 @@ function isNeoScriptTypeAssignable(source, target, project) {
       return expected !== void 0 && isNeoScriptTypeAssignable(parameter4, expected, project) && isNeoScriptTypeAssignable(expected, parameter4, project);
     });
   }
+  if (source.kind === "action" && target.kind === "action") {
+    return source.parameterTypes.length === target.parameterTypes.length && source.parameterTypes.every((parameter4, index) => {
+      const expected = target.parameterTypes[index];
+      return expected !== void 0 && isNeoScriptTypeAssignable(parameter4, expected, project) && isNeoScriptTypeAssignable(expected, parameter4, project);
+    });
+  }
   return false;
 }
 function commonNeoScriptAssignableType(left, right, project) {
@@ -2019,6 +2026,8 @@ function formatType(type, project) {
           (parameter4) => formatType(parameter4, project)
         )
       ].join(", ")}>${suffix}`;
+    case "action":
+      return `NeoAction<${type.parameterTypes.map((parameter4) => formatType(parameter4, project)).join(", ")}>${suffix}`;
   }
 }
 var UNKNOWN_TYPE;
@@ -6919,6 +6928,8 @@ function neoScriptPositionalTypeKey(type) {
       return `typeParameter:${type.id}`;
     case "delegate":
       return `delegate:${neoScriptPositionalTypeKey(type.returnType)}(${type.parameterTypes.map(neoScriptPositionalTypeKey).join(",")})`;
+    case "action":
+      return `action:(${type.parameterTypes.map(neoScriptPositionalTypeKey).join(",")})`;
   }
 }
 function validateNeoScriptOverloadSignatures(className, signatures) {
@@ -7485,8 +7496,34 @@ function typeRefsEqual(left, right) {
       return other !== void 0 && typeRefsEqual(parameter4, other);
     });
   }
+  if (left.kind === "action" && right.kind === "action") {
+    return left.parameterTypes.length === right.parameterTypes.length && left.parameterTypes.every((parameter4, index) => {
+      const other = right.parameterTypes[index];
+      return other !== void 0 && typeRefsEqual(parameter4, other);
+    });
+  }
   return left.kind === "dictionary" && right.kind === "dictionary" ? typeRefsEqual(left.keyType, right.keyType) && typeRefsEqual(left.valueType, right.valueType) : false;
 }
+function actionListenerSignature(symbol) {
+  if (symbol.kind === "function" || symbol.kind === "method") {
+    return {
+      returnsVoid: isVoid(symbol.returnType ?? symbol.type),
+      parameterTypes: (symbol.parameters ?? []).map(
+        (parameter4) => parameter4.type
+      )
+    };
+  }
+  if (symbol.type.kind === "delegate") {
+    return {
+      returnsVoid: isVoid(symbol.type.returnType),
+      parameterTypes: symbol.type.parameterTypes
+    };
+  }
+  if (symbol.type.kind === "action") {
+    return { returnsVoid: true, parameterTypes: symbol.type.parameterTypes };
+  }
+  return null;
+}
 function variable(id2, type, pointer, project) {
   return {
     id: id2,
@@ -7867,6 +7904,14 @@ function toWireType(type, project) {
           (parameter4) => toWireType(parameter4, project)
         )
       };
+    case "action":
+      return {
+        type: 26 /* Action */,
+        required: true,
+        argumentTypes: type.parameterTypes.map(
+          (parameter4) => toWireType(parameter4, project)
+        )
+      };
   }
 }
 function fromWireType(type) {
@@ -7921,6 +7966,12 @@ function fromWireType(type) {
       nullable
     };
   }
+  if (type.type === 26 /* Action */) {
+    return {
+      kind: "action",
+      parameterTypes: type.argumentTypes.map(fromWireType)
+    };
+  }
   return { kind: "primitive", name: valueKindPrimitive(type.type), nullable };
 }
 function findGenericParameterOwner(parameterId, project) {
@@ -8149,10 +8200,17 @@ function substituteTypeParameters(member, receiver, declaring) {
         parameterTypes: type.parameterTypes.map(visit)
       };
     }
+    if (type.kind === "action") {
+      return { ...type, parameterTypes: type.parameterTypes.map(visit) };
+    }
     return type;
   };
   return visit(member);
 }
+function isActionMemberPointer(pointer) {
+  if (pointer.type === "staticMember" /* StaticMember */) return true;
+  return pointer.type === "keyOf" /* KeyOf */;
+}
 function pointerToBooleanExpression(pointer) {
   if (pointer.type === "operation" /* Operation */ && pointer.operation.type === "boolean" /* Boolean */) {
     return pointer.operation.expression;
@@ -8771,6 +8829,12 @@ var init_strict_resolver = __esm({
                 statement.init.pos
               );
             }
+            if (initial.type.kind === "action") {
+              throw new CompileError(
+                `Cannot bind ${this.describe(initial.type)} to local '${statement.name}'; an action is not a value. Subscribe or invoke it through the member reference directly.`,
+                statement.init.pos
+              );
+            }
             const localType = declared ?? initial.type;
             if (declared) {
               this.requireAssignable(
@@ -9003,6 +9067,12 @@ var init_strict_resolver = __esm({
               statement.iterator,
               iteratorScope
             );
+            if (iterator.type !== "assign" /* Assign */) {
+              throw new CompileError(
+                "A for-loop iterator must be an assignment; an NSAction subscription is not a valid iterator.",
+                statement.iterator.pos
+              );
+            }
             const initialConditionFalseScope = new Scope(loopScope);
             this.applyFactsToScope(loopScope, initialConditionFalseScope, [
               ...factsWhenFalse(statement.condition)
@@ -9593,6 +9663,15 @@ var init_strict_resolver = __esm({
           scope,
           false
         );
+        if (target.type.kind === "action") {
+          return this.resolveActionSubscription(
+            statement,
+            target,
+            target.type,
+            writability,
+            scope
+          );
+        }
         let value;
         if (statement.op === "=") {
           if (!statement.value) {
@@ -9675,6 +9754,189 @@ var init_strict_resolver = __esm({
           pos
         );
       }
+      /**
+       * P62 §3.2. `+=` / `-=` on an NSAction member are subscription operators,
+       * not arithmetic: the listener set *is* the member's value, so each one
+       * compiles to a member-value write carrying the listener target.
+       */
+      resolveActionSubscription(statement, target, actionType, writability, scope) {
+        if (statement.op === "=") {
+          throw new CompileError(
+            `Cannot assign to ${this.describe(actionType)}; a listener set is not reassignable from script. Use '+=' to add a listener or '-=' to remove one.`,
+            statement.pos
+          );
+        }
+        if (statement.op !== "+=" && statement.op !== "-=") {
+          throw new CompileError(
+            `Operator '${statement.op}' cannot be applied to ${this.describe(actionType)}; an action supports only '+=' and '-='.`,
+            statement.pos
+          );
+        }
+        if (!isActionMemberPointer(target.pointer)) {
+          throw new CompileError(
+            `Cannot apply '${statement.op}' to ${this.describe(actionType)} that is not a member reference; an action is not a value. Subscribe or invoke it through the member reference directly.`,
+            statement.pos
+          );
+        }
+        if (!statement.value) {
+          throw new CompileError(
+            `Assignment operator '${statement.op}' requires a right-hand listener.`,
+            statement.pos
+          );
+        }
+        const listener = this.resolveActionListener(
+          statement.value,
+          actionType,
+          scope
+        );
+        const assignedPath = canonicalPath(statement.target);
+        if (assignedPath) {
+          const rootEntry = scope.lookup(pathRoot(assignedPath));
+          if (rootEntry) scope.invalidate(rootEntry);
+        }
+        const kind = statement.op === "+=" ? "addActionListener" /* AddActionListener */ : "removeActionListener" /* RemoveActionListener */;
+        return {
+          type: kind,
+          target: {
+            pointer: target.pointer,
+            typeInfo: target.wireType ?? toWireType(actionType, this.project),
+            writability
+          },
+          listener
+        };
+      }
+      /**
+       * Lowers a `+=` / `-=` right-hand side to the member target a listener is
+       * (P62 §3.2). A listener is always a member reference, so the accepted forms
+       * are exactly the ones the authored listener list accepts: a method group or
+       * a delegate/action-typed member on the current class, or the same through a
+       * value alias or a static type name.
+       */
+      resolveActionListener(expression, expected, scope) {
+        if (expression.kind === "lambda") {
+          throw new CompileError(
+            `A lambda cannot be an action listener: a closure has no identity to deduplicate or remove by. Extract the body to an NSFunction member and subscribe that member instead.`,
+            expression.pos
+          );
+        }
+        const resolved = this.resolveActionListenerSymbol(expression, scope);
+        if (resolved === null) {
+          throw new CompileError(
+            `An action listener must be a Function, NSFunction, NeoDelegate, or NeoAction member reference.`,
+            expression.pos
+          );
+        }
+        const { symbol, owner, receiverType, valueId } = resolved;
+        if (owner !== void 0) {
+          this.assertMemberAccessible(owner, symbol, expression.pos);
+        }
+        if (symbol.deferred === true) {
+          throw new CompileError(
+            `Deferred member '${symbol.name}' cannot be an action listener; listeners run immediately.`,
+            expression.pos
+          );
+        }
+        this.requireActionListenerSignature(
+          symbol,
+          owner,
+          receiverType,
+          expected,
+          expression.pos
+        );
+        return {
+          type: "value" /* Value */,
+          value: {
+            typeInfo: toWireType(expected, this.project),
+            value: { memberId: symbol.id, valueId }
+          }
+        };
+      }
+      /**
+       * Resolves the member a listener expression names, along with the row the
+       * target binds to. `valueId` is `null` for a member on the current class or
+       * a static member — the same identity the authored listener list lowers to
+       * — and a value alias contributes its own stable row.
+       */
+      resolveActionListenerSymbol(expression, scope) {
+        if (expression.kind === "ident") {
+          const implicit = this.implicitMember(expression.name);
+          if (implicit === null) return null;
+          return {
+            symbol: implicit.symbol,
+            owner: implicit.owner,
+            receiverType: this.context.thisClass,
+            valueId: null
+          };
+        }
+        if (expression.kind !== "member") return null;
+        if (expression.receiver.kind === "ident" && !scope.lookup(expression.receiver.name)) {
+          const owner2 = this.project.typeByName.get(expression.receiver.name);
+          const symbol2 = owner2?.members.find(
+            (candidate) => candidate.name === expression.name
+          );
+          if (owner2 === void 0 || symbol2 === void 0) return null;
+          if (symbol2.static !== true) {
+            throw new CompileError(
+              `Member '${owner2.name}.${symbol2.name}' requires an instance receiver.`,
+              expression.pos
+            );
+          }
+          return { symbol: symbol2, owner: owner2, receiverType: void 0, valueId: null };
+        }
+        const receiver = this.resolveExpression(expression.receiver, scope);
+        if (receiver.type.kind !== "named") return null;
+        const owner = this.project.typeById.get(receiver.type.typeId);
+        const symbol = owner?.members.find(
+          (candidate) => candidate.name === expression.name
+        );
+        if (owner === void 0 || symbol === void 0) return null;
+        if (expression.receiver.kind === "ident" && expression.receiver.name === "this") {
+          return { symbol, owner, receiverType: receiver.type, valueId: null };
+        }
+        if (receiver.pointer.type !== "reference" /* Reference */) {
+          throw new CompileError(
+            `Listener '${symbol.name}' cannot be subscribed through this receiver: a listener target is a stable (member, row) identity, so the receiver must be \`this\`, a project value, or a type name.`,
+            expression.pos
+          );
+        }
+        return {
+          symbol,
+          owner,
+          receiverType: receiver.type,
+          valueId: receiver.pointer.valueId
+        };
+      }
+      /**
+       * P62 §2.1. A listener's effective signature must be void-returning with
+       * pairwise-identical post-substitution parameter types — the method-group
+       * discipline with void-ness fixed true. A delegate or action member is
+       * accepted by the signature it carries: subscribing it is an indirection
+       * through the member, not a snapshot of its current value.
+       */
+      requireActionListenerSignature(symbol, owner, receiverType, expected, pos) {
+        const substitute2 = (type) => {
+          if (receiverType?.kind !== "named" || owner === void 0) return type;
+          return substituteTypeParameters(type, receiverType, owner);
+        };
+        const signature = actionListenerSignature(symbol);
+        if (signature === null) {
+          throw new CompileError(
+            `'${symbol.name}' is not a callable member, so it cannot be an action listener.`,
+            pos
+          );
+        }
+        const parameterTypes = signature.parameterTypes.map(substitute2);
+        const matches = signature.returnsVoid && parameterTypes.length === expected.parameterTypes.length && parameterTypes.every((parameter4, index) => {
+          const slot = expected.parameterTypes[index];
+          return slot !== void 0 && isNeoScriptTypeAssignable(parameter4, slot, this.project) && isNeoScriptTypeAssignable(slot, parameter4, this.project);
+        });
+        if (!matches) {
+          throw new CompileError(
+            `Listener '${symbol.name}' is not assignable to ${this.describe(expected)}.`,
+            pos
+          );
+        }
+      }
       resolveExpression(expression, scope, expected) {
         if (expected?.kind === "delegate") {
           if (expression.kind === "lambda") {
@@ -9687,6 +9949,12 @@ var init_strict_resolver = __esm({
           );
           if (methodGroup !== null) return methodGroup;
         }
+        if (expected?.kind === "action" && expression.kind === "lambda") {
+          throw new CompileError(
+            "A lambda cannot be an action listener: a closure has no identity to deduplicate or remove by. Extract the body to an NSFunction member and subscribe that member instead.",
+            expression.pos
+          );
+        }
         switch (expression.kind) {
           case "litNull":
             return literal(
@@ -11032,6 +11300,13 @@ var init_strict_resolver = __esm({
             callee.kind === "member" && callee.optional === true
           );
         }
+        const action = this.resolveActionCallee(callee, scope);
+        if (action !== null) {
+          throw new CompileError(
+            `${this.describe(action.type)} is void and cannot be used as a value; call it as a statement instead.`,
+            pos
+          );
+        }
         if (callee.kind === "ident") {
           const vector = vectorKind(callee.name);
           if (vector)
@@ -11254,6 +11529,37 @@ var init_strict_resolver = __esm({
           throw error;
         }
       }
+      /**
+       * The action-typed sibling of {@link resolveDelegateCallee}. Kept separate
+       * so an action never leaks into the delegate call path: an action is
+       * statement-only, and its two call sites want opposite outcomes — the
+       * statement path compiles it, the expression path rejects it.
+       */
+      resolveActionCallee(callee, scope) {
+        if (callee.kind === "ident") {
+          const scoped = scope.lookup(callee.name);
+          const implicit = this.implicitMember(callee.name);
+          if (scoped === null && (implicit === null || implicit.symbol.kind === "function" || implicit.symbol.kind === "method")) {
+            return null;
+          }
+          const resolved = this.resolveIdentifier(callee.name, scope, callee.pos);
+          return resolved.type.kind === "action" ? resolved : null;
+        }
+        if (callee.kind !== "member") return null;
+        try {
+          const resolved = this.resolveMember(
+            callee.receiver,
+            callee.name,
+            scope,
+            callee.pos,
+            callee.optional === true
+          );
+          return resolved.type.kind === "action" ? resolved : null;
+        } catch (error) {
+          if (error instanceof CompileError) return null;
+          throw error;
+        }
+      }
       resolveDelegateCall(delegate, args, scope, pos, optional) {
         if (delegate.type.kind !== "delegate") {
           throw new Error("Delegate call received a non-delegate type.");
@@ -12448,8 +12754,48 @@ var init_strict_resolver = __esm({
           writeRoot: inferredWriteRoot ?? "unknown"
         };
       }
+      /**
+       * P62 §3.1. Statement-position invoke: every listener fires in stored order
+       * and an empty listener set is a successful no-op, so there is nothing to
+       * return and no optional form to carry.
+       */
+      resolveActionCall(action, actionType, expression, scope) {
+        if (expression.callee.kind === "member" && expression.callee.optional) {
+          throw new CompileError(
+            `${this.describe(actionType)} is never null, so optional-chained invocation is not supported.`,
+            expression.pos
+          );
+        }
+        requireArgCount(
+          "Action",
+          expression.args,
+          actionType.parameterTypes.length,
+          expression.pos
+        );
+        const args = expression.args.map((argument2, index) => {
+          const expected = requiredAt(actionType.parameterTypes, index);
+          const resolved = this.resolveExpression(argument2, scope, expected);
+          this.requireAssignable(
+            resolved.type,
+            expected,
+            argument2.pos,
+            `action argument ${index + 1}`
+          );
+          return resolved.pointer;
+        });
+        return {
+          type: "callAction" /* CallAction */,
+          action: action.pointer,
+          args,
+          callSiteId: this.nextCallSite(expression.pos)
+        };
+      }
       resolveFunctionStatement(expression, scope) {
         if (expression.kind !== "call") return null;
+        const action = this.resolveActionCallee(expression.callee, scope);
+        if (action?.type.kind === "action") {
+          return this.resolveActionCall(action, action.type, expression, scope);
+        }
         const delegate = this.resolveDelegateCallee(expression.callee, scope);
         if (delegate?.type.kind === "delegate") {
           const delegateType = delegate.type;
@@ -21797,6 +22143,9 @@ function substituteInheritedSourceMember(member, baseInfo, resolvedBaseType) {
         parameterTypes: type.parameterTypes.map(substitute2)
       };
     }
+    if (type.kind === "action") {
+      return { ...type, parameterTypes: type.parameterTypes.map(substitute2) };
+    }
     return type;
   };
   return {
@@ -21876,6 +22225,14 @@ function sourceTypeRef(type, owner, typeIds) {
       ...nullable ? { nullable } : {}
     };
   }
+  if (type.name === "NeoAction") {
+    return {
+      kind: "action",
+      parameterTypes: type.typeArguments.map(
+        (argument2) => sourceTypeRef(argument2, owner, typeIds)
+      )
+    };
+  }
   if (type.name === "Reference" && type.typeArguments[0]) {
     return {
       ...sourceTypeRef(type.typeArguments[0], owner, typeIds),
@@ -22606,6 +22963,27 @@ function validateTypeApplication(uri, type, genericParameters, environment, diag
     }
     return;
   }
+  if (type.name === "NeoAction") {
+    if (type.typeArguments.length > 16) {
+      diagnose(
+        diagnostics,
+        uri,
+        type.range,
+        "generic-argument-arity",
+        `Type 'NeoAction' expects up to 16 parameter types, but ${type.typeArguments.length} type arguments were provided.`
+      );
+    }
+    if (type.nullable) {
+      diagnose(
+        diagnostics,
+        uri,
+        type.range,
+        "action-nullable",
+        "Type 'NeoAction' cannot be nullable; an action's rest state is an empty listener set, not null."
+      );
+    }
+    return;
+  }
   const expected = target?.declaration.kind === "class" ? target.declaration.genericParameters.length : BUILTIN_ARITY.get(type.name) ?? 0;
   if (!target && !BUILTIN_TYPES.has(type.name)) return;
   if (type.typeArguments.length !== expected) {
@@ -22653,6 +23031,16 @@ function validateTypeApplication(uri, type, genericParameters, environment, diag
   });
 }
 function validateMemberTypeKind(uri, type, context, name, diagnostics) {
+  if (type.name === "NeoAction" && context === "return") {
+    diagnose(
+      diagnostics,
+      uri,
+      type.range,
+      "invalid-member-type",
+      `Function '${name}' cannot return 'NeoAction'; an action is invoked as a statement, never used as a value.`
+    );
+    return;
+  }
   if (context === "return") return;
   if (type.name !== "void" && type.name !== "null") return;
   diagnose(
@@ -30888,6 +31276,24 @@ function memberFromDocument(record3, members, owners, classNames, context) {
       )
     };
   }
+  if (kind === MEMBER_KIND.NSAction) {
+    if (common.required === true) {
+      throw invalidDocument(
+        record3,
+        "required",
+        "an NSAction member is never nullable"
+      );
+    }
+    return {
+      ...common,
+      kind: "action",
+      arguments: documentArgumentsToManifest(
+        field("argumentTypes", []),
+        record3,
+        source.span
+      )
+    };
+  }
   if (kind === MEMBER_KIND.Generic) {
     return {
       ...common,
@@ -31033,6 +31439,12 @@ function memberToDocumentFields(member, baseData3) {
       ...manifestTypeToDocument(argument2.type)
     }));
   }
+  if (member.kind === "action") {
+    fields.argumentTypes = member.arguments.map((argument2) => ({
+      name: argument2.name,
+      ...manifestTypeToDocument(argument2.type)
+    }));
+  }
   if (member.kind === "generic") {
     fields.genericParamId = member.genericParamId;
     if (member.partial) fields.partial = true;
@@ -31248,6 +31660,26 @@ function documentTypeToManifest(value, record3, path) {
       )
     };
   }
+  if (kind === MEMBER_KIND.NSAction) {
+    if (nullable) {
+      throw invalidDocument(
+        record3,
+        `${path}.required`,
+        "an NeoAction type is never nullable"
+      );
+    }
+    return {
+      kind: "action",
+      nullable: false,
+      argumentTypes: optionalArray(typeInfo.argumentTypes).map(
+        (argument2, index) => documentTypeToManifest(
+          argument2,
+          record3,
+          `${path}.argumentTypes.${index}`
+        )
+      )
+    };
+  }
   throw invalidDocument(
     record3,
     path,
@@ -31319,6 +31751,13 @@ function manifestTypeToDocument(type) {
       argumentTypes: type.argumentTypes.map(manifestTypeToDocument)
     };
   }
+  if (type.kind === "action") {
+    return {
+      type: MEMBER_KIND.NSAction,
+      required: true,
+      argumentTypes: type.argumentTypes.map(manifestTypeToDocument)
+    };
+  }
   if (type.kind !== "lookup") {
     throw new Error(`No document type-info mapping for ${type.kind}.`);
   }
@@ -31711,7 +32150,8 @@ var init_codecs = __esm({
       Interface: 22,
       NSFunction: 23,
       FunctionRef: 24,
-      NSDelegate: 25
+      NSDelegate: 25,
+      NSAction: 26
     };
     TYPE_KIND_BY_MEMBER_KIND = /* @__PURE__ */ new Map([
       [MEMBER_KIND.Null, "null"],
@@ -31763,7 +32203,8 @@ var init_codecs = __esm({
       ["generic", MEMBER_KIND.Generic],
       ["scriptFunction", MEMBER_KIND.NSFunction],
       ["functionRef", MEMBER_KIND.FunctionRef],
-      ["delegate", MEMBER_KIND.NSDelegate]
+      ["delegate", MEMBER_KIND.NSDelegate],
+      ["action", MEMBER_KIND.NSAction]
     ]);
     TYPE_MEMBER_KIND_BY_KIND = /* @__PURE__ */ new Map([
       ["null", MEMBER_KIND.Null],
@@ -33967,6 +34408,16 @@ function assertMember2(value, path) {
     }
     return;
   }
+  if (kind === "action") {
+    arrayOf(member.arguments, `${path}.arguments`, assertFunctionArgument);
+    if (Array.isArray(member.arguments) && member.arguments.length > 16) {
+      invalid(`${path}.arguments`, "action arity cannot exceed 16.");
+    }
+    if (member.required !== false) {
+      invalid(`${path}.required`, "an action member is never nullable.");
+    }
+    return;
+  }
   if (kind === "generic") {
     nonEmptyString(member.genericParamId, `${path}.genericParamId`);
     if (member.partial !== void 0) {
@@ -34289,6 +34740,19 @@ function assertType2(value, path, depth = 0) {
     }
     return;
   }
+  if (kind === "action") {
+    knownKeys(type, path, ["kind", "nullable", "argumentTypes"]);
+    exactValue(type.nullable, false, `${path}.nullable`);
+    arrayOf(
+      type.argumentTypes,
+      `${path}.argumentTypes`,
+      (entry, entryPath) => assertType2(entry, entryPath, depth + 1)
+    );
+    if (Array.isArray(type.argumentTypes) && type.argumentTypes.length > 16) {
+      invalid(`${path}.argumentTypes`, "action arity cannot exceed 16.");
+    }
+    return;
+  }
   invalid(`${path}.kind`, `unsupported schema type ${JSON.stringify(kind)}.`);
 }
 function assertInterface(value, path) {
@@ -35191,7 +35655,10 @@ var init_validate = __esm({
       scriptFunction: ["returnType", "arguments", "deferred", "script"],
       generic: ["genericParamId"],
       functionRef: [],
-      delegate: ["returnType", "arguments"]
+      delegate: ["returnType", "arguments"],
+      // P62 §2.1: an action is structurally void, so `arguments` is the only
+      // kind-specific key it carries.
+      action: ["arguments"]
     };
     PRIMITIVE_TYPE_KINDS = /* @__PURE__ */ new Set([
       "null",
@@ -36255,6 +36722,23 @@ function isNSTypeInfoDelegateInternal(value, ancestors) {
     ancestors.delete(delegate);
   }
 }
+function isNSTypeInfoActionInternal(value, ancestors) {
+  if (!isNSTypeInfoBase(value) || value.type !== 26 /* NSAction */) {
+    return false;
+  }
+  const action = value;
+  if (ancestors.has(action)) return false;
+  ancestors.add(action);
+  try {
+    if (!Array.isArray(action.argumentTypes)) return false;
+    if (action.argumentTypes.length > 16) return false;
+    return action.argumentTypes.every(
+      (argument2) => isNSTypeInfoInternal(argument2, ancestors)
+    );
+  } finally {
+    ancestors.delete(action);
+  }
+}
 function isNSTypeInfoCollection(value) {
   return isNSTypeInfoCollectionInternal(value, /* @__PURE__ */ new Set());
 }
@@ -36311,7 +36795,7 @@ function isNSTypeInfo(value) {
   return isNSTypeInfoInternal(value, /* @__PURE__ */ new Set());
 }
 function isNSTypeInfoInternal(value, ancestors) {
-  return isNSTypeInfoUnknown(value) || isNSTypeInfoPrimitive(value) || isNSTypeInfoAsset(value) || isNSTypeInfoVector(value) || isNSTypeInfoColor(value) || isNSTypeInfoDialogueLookup(value) || isNSTypeInfoClassInternal(value, ancestors) || isNSTypeInfoInterface(value) || isNSTypeInfoGenericParam(value) || isNSTypeInfoDelegateInternal(value, ancestors) || isNSTypeInfoCollectionInternal(value, ancestors) || isNSTypeInfoLookupInternal(value, ancestors) || isNSTypeInfoEnum(value);
+  return isNSTypeInfoUnknown(value) || isNSTypeInfoPrimitive(value) || isNSTypeInfoAsset(value) || isNSTypeInfoVector(value) || isNSTypeInfoColor(value) || isNSTypeInfoDialogueLookup(value) || isNSTypeInfoClassInternal(value, ancestors) || isNSTypeInfoInterface(value) || isNSTypeInfoGenericParam(value) || isNSTypeInfoDelegateInternal(value, ancestors) || isNSTypeInfoActionInternal(value, ancestors) || isNSTypeInfoCollectionInternal(value, ancestors) || isNSTypeInfoLookupInternal(value, ancestors) || isNSTypeInfoEnum(value);
 }
 function isNSArgumentTypeInfo(value) {
   return isRequiredType(value, isNSArgumentTypeInfoUnsafe);
@@ -36338,6 +36822,11 @@ function typeInfoContainsUnknown(value, ancestors) {
         (argument2) => typeInfoContainsUnknown(argument2, ancestors)
       );
     }
+    if (value.type === 26 /* NSAction */) {
+      return value.argumentTypes.some(
+        (argument2) => typeInfoContainsUnknown(argument2, ancestors)
+      );
+    }
     if (value.type !== 7 /* Class */) return false;
     return Object.values(value.typeArguments ?? {}).some(
       (argument2) => typeInfoContainsUnknown(argument2, ancestors)
@@ -36488,6 +36977,16 @@ function isNSPointerCallDelegate(value) {
   }
   return v.optional === void 0 || typeof v.optional === "boolean";
 }
+function isNSPointerCallAction(value) {
+  const v = value;
+  if (v?.type !== "callAction" /* callAction */) return false;
+  if (!isNSPointer(v.action)) return false;
+  if (!Array.isArray(v.args) || !v.args.every(isNSPointer)) return false;
+  if (typeof v.callSiteId !== "string" || v.callSiteId.length === 0) {
+    return false;
+  }
+  return v.optional === void 0;
+}
 function isNSCallReceiver(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
@@ -36506,7 +37005,7 @@ function isNSPointerFunctionErrorCheck(value) {
   return isNSFunctionErrorCheckMode(v.mode);
 }
 function isNSPointer(value) {
-  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerStaticMember(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerCallFunction(value) || isNSPointerCallDelegate(value) || isNSPointerFunctionErrorCheck(value);
+  return isNSPointerReference(value) || isNSPointerVariable(value) || isNSPointerStaticMember(value) || isNSPointerValue(value) || isNSPointerOperation(value) || isNSPointerFunction(value) || isNSPointerKeyOf(value) || isNSPointerListLiteral(value) || isNSPointerDictLiteral(value) || isNSPointerForceUnwrap(value) || isNSPointerIsCheck(value) || isNSPointerCallGetter(value) || isNSPointerCoalesce(value) || isNSPointerToBool(value) || isNSPointerStringify(value) || isNSPointerCallFunction(value) || isNSPointerCallDelegate(value) || isNSPointerCallAction(value) || isNSPointerFunctionErrorCheck(value);
 }
 function isNSPointers(value) {
   return Array.isArray(value) && value.every(isNSPointer);
@@ -36589,6 +37088,12 @@ function isNSFunctionWithReturnType(value) {
   if (nsInstructionsContainType(v.instructions, "try" /* try */) && (v.compilerRevision ?? 1) < 6) {
     return false;
   }
+  if ((v.compilerRevision ?? 1) < 8 && ([
+    "addActionListener" /* addActionListener */,
+    "removeActionListener" /* removeActionListener */
+  ].some((type) => nsInstructionsContainType(v.instructions ?? [], type)) || nsIRContainsPointerType(v.instructions, "callAction" /* callAction */))) {
+    return false;
+  }
   if (!isNSTypeInfo(v.typeInfo)) return false;
   return true;
 }
@@ -36814,18 +37319,39 @@ function isNSInstructionThrow(value) {
   if (v?.type !== "throw" /* throw */) return false;
   return isNSPointer(v.pointer);
 }
+function isNSWriteTarget(value) {
+  const target = value;
+  if (!target) return false;
+  if (!isNSPointer(target.pointer)) return false;
+  if (!isNSTypeInfo(target.typeInfo)) return false;
+  if (target.writability === void 0) return true;
+  return Object.values(NSWritability).includes(target.writability);
+}
 function isNSInstructionAssign(value) {
   const v = value;
   if (v?.type !== "assign" /* assign */) return false;
   if (v.operator === void 0) return false;
   if (!Object.values(NSAssignmentOperator).includes(v.operator)) return false;
   if (!isNSPointer(v.pointer)) return false;
-  const target = v.target;
-  if (!target) return false;
-  if (!isNSPointer(target.pointer)) return false;
-  if (!isNSTypeInfo(target.typeInfo)) return false;
-  if (target.writability === void 0) return true;
-  return Object.values(NSWritability).includes(target.writability);
+  return isNSWriteTarget(v.target);
+}
+function isNSInstructionActionListener(value, type) {
+  const v = value;
+  if (v?.type !== type) return false;
+  if (!isNSWriteTarget(v.target)) return false;
+  return isNSPointer(v.listener);
+}
+function isNSInstructionAddActionListener(value) {
+  return isNSInstructionActionListener(
+    value,
+    "addActionListener" /* addActionListener */
+  );
+}
+function isNSInstructionRemoveActionListener(value) {
+  return isNSInstructionActionListener(
+    value,
+    "removeActionListener" /* removeActionListener */
+  );
 }
 function isNSInstructionCollectionCall(value) {
   const v = value;
@@ -36834,17 +37360,14 @@ function isNSInstructionCollectionCall(value) {
   if (!Object.values(NSCollectionMutation).includes(v.mutation)) return false;
   if (!Array.isArray(v.args)) return false;
   if (!v.args.every(isNSPointer)) return false;
-  const target = v.target;
-  if (!target) return false;
-  if (!isNSPointer(target.pointer)) return false;
-  if (!isNSTypeInfo(target.typeInfo)) return false;
-  if (target.writability === void 0) return true;
-  return Object.values(NSWritability).includes(target.writability);
+  return isNSWriteTarget(v.target);
 }
 function isNSInstructionFunctionCall(value) {
   const v = value;
   if (v?.type !== "functionCall" /* functionCall */) return false;
-  return isNSPointerCallFunction(v.call) || isNSPointerCallDelegate(v.call);
+  if (isNSPointerCallFunction(v.call)) return true;
+  if (isNSPointerCallDelegate(v.call)) return true;
+  return isNSPointerCallAction(v.call);
 }
 function isNSLoopBinding(value) {
   const binding = value;
@@ -36974,7 +37497,7 @@ function isNSInstructionTry(value) {
   return true;
 }
 function isNSInstruction(value) {
-  return isNSInstructionVariable(value) || isNSInstructionIfBranch(value) || isNSInstructionReturn(value) || isNSInstructionThrow(value) || isNSInstructionAssign(value) || isNSInstructionCollectionCall(value) || isNSInstructionFunctionCall(value) || isNSInstructionFor(value) || isNSInstructionForEach(value) || isNSInstructionBreak(value) || isNSInstructionContinue(value) || isNSInstructionSwitch(value) || isNSInstructionTry(value);
+  return isNSInstructionVariable(value) || isNSInstructionIfBranch(value) || isNSInstructionReturn(value) || isNSInstructionThrow(value) || isNSInstructionAssign(value) || isNSInstructionCollectionCall(value) || isNSInstructionFunctionCall(value) || isNSInstructionFor(value) || isNSInstructionForEach(value) || isNSInstructionBreak(value) || isNSInstructionContinue(value) || isNSInstructionSwitch(value) || isNSInstructionTry(value) || isNSInstructionAddActionListener(value) || isNSInstructionRemoveActionListener(value);
 }
 function nsInstructionsContainType(instructions, type) {
   return instructions.some((instruction) => {
@@ -37000,6 +37523,21 @@ function nsInstructionsContainType(instructions, type) {
     return false;
   });
 }
+function nsIRContainsPointerType(node, type, visited = /* @__PURE__ */ new Set()) {
+  if (Array.isArray(node)) {
+    return node.some((entry) => nsIRContainsPointerType(entry, type, visited));
+  }
+  if (typeof node !== "object" || node === null) return false;
+  if (visited.has(node)) return false;
+  visited.add(node);
+  const record3 = node;
+  if (record3.type === type) return true;
+  const isLiteralValue = "typeInfo" in record3 && "value" in record3 && !("type" in record3);
+  return Object.entries(record3).some(([key, child]) => {
+    if (isLiteralValue && key === "value") return false;
+    return nsIRContainsPointerType(child, type, visited);
+  });
+}
 function isNSInstructions(value) {
   return Array.isArray(value) && value.every(isNSInstruction);
 }
@@ -37041,7 +37579,7 @@ function isNSBoolGetter(value) {
   if (value.typeInfo.type !== 1 /* Bool */) return false;
   return value.typeInfo.required === true;
 }
-function isNSVoidAction(value) {
+function isNSVoidBody(value) {
   if (!isNSFunctionWithReturnType(value)) return false;
   if (value.typeInfo.type !== 0 /* Null */) return false;
   return value.typeInfo.required === true;
@@ -37177,6 +37715,12 @@ function typeInfosInvariantlyEqual(left, right) {
     if (left.keyEnumId !== right.keyEnumId) return false;
     return typeInfosInvariantlyEqual(left.entryTypeInfo, right.entryTypeInfo);
   }
+  if (left.type === 26 /* NSAction */ && right.type === 26 /* NSAction */) {
+    if (left.argumentTypes.length !== right.argumentTypes.length) return false;
+    return left.argumentTypes.every(
+      (argument2, index) => typeInfosInvariantlyEqual(argument2, right.argumentTypes[index])
+    );
+  }
   if (left.type === 9 /* Lookup */ && right.type === 9 /* Lookup */) {
     if (left.collectionMemberId !== right.collectionMemberId) return false;
     if (left.collectionValueId !== right.collectionValueId) return false;
@@ -37377,6 +37921,7 @@ var init_member_kind_enum = __esm({
       MemberKind14[MemberKind14["NSFunction"] = 23] = "NSFunction";
       MemberKind14[MemberKind14["FunctionRef"] = 24] = "FunctionRef";
       MemberKind14[MemberKind14["NSDelegate"] = 25] = "NSDelegate";
+      MemberKind14[MemberKind14["NSAction"] = 26] = "NSAction";
       return MemberKind14;
     })(MemberKind || {});
   }
@@ -37798,8 +38343,8 @@ function isMemberNSProperty(value) {
   const setterCode = getField(value, "setterCode");
   const setter = getField(value, "setter");
   if (setter !== void 0 && setterCode === void 0) return false;
-  if (setterCode !== void 0 && !isNSVoidAction(setter)) return false;
-  return setter === void 0 || isNSVoidAction(setter);
+  if (setterCode !== void 0 && !isNSVoidBody(setter)) return false;
+  return setter === void 0 || isNSVoidBody(setter);
 }
 function isFileValue(value) {
   const v = value;
@@ -37891,7 +38436,7 @@ function hasValidNSFunctionAction(value, returnTypeInfo, argumentTypes) {
   );
 }
 function isNSFunctionUIBody(value) {
-  if (!isNSVoidAction(value)) return false;
+  if (!isNSVoidBody(value)) return false;
   if (value.instructions.length !== 1) return false;
   const instruction = value.instructions[0];
   if (instruction === void 0) return false;
@@ -38003,6 +38548,44 @@ function isMemberDelegateBase(value) {
   if (isInitValueContent(defaultValue)) return true;
   return isNSDelegateValue(defaultValue.value);
 }
+function nsActionListenerIdentity(listener) {
+  return `${listener.memberId} ${listener.valueId ?? ""}`;
+}
+function isNSActionValue(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record3 = value;
+  if (!hasExactKeys(record3, ["listeners"])) return false;
+  if (!Array.isArray(record3.listeners)) return false;
+  const identities = /* @__PURE__ */ new Set();
+  for (const listener of record3.listeners) {
+    if (!isMemberDelegateTarget(listener)) return false;
+    const identity2 = nsActionListenerIdentity(listener);
+    if (identities.has(identity2)) return false;
+    identities.add(identity2);
+  }
+  return true;
+}
+function isMemberActionBase(value) {
+  const v = asMemberBaseForKind(value, 26 /* NSAction */);
+  if (v === null) return false;
+  if (v.required === true) return false;
+  if (!Array.isArray(v.argumentTypes) || v.argumentTypes.length > 16) {
+    return false;
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const argument2 of v.argumentTypes) {
+    if (!isNSFunctionArgumentTypeInfo(argument2)) return false;
+    if (!isValidCallableIdentifier(argument2.name)) return false;
+    if (argument2.type === NS_TYPE_UNKNOWN) return false;
+    if (names.has(argument2.name)) return false;
+    names.add(argument2.name);
+  }
+  const defaultValue = v.defaultValue;
+  if (defaultValue === void 0 || defaultValue === null) return true;
+  if (!isMemberValueBase(defaultValue)) return false;
+  if (isInitValueContent(defaultValue)) return true;
+  return isNSActionValue(defaultValue.value);
+}
 function isFunctionRefValue(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
   const record3 = value;
@@ -38067,7 +38650,7 @@ function isMemberBase(value) {
   if (partial !== void 0 && v?.kind !== 7 /* Class */ && v?.kind !== 21 /* Generic */) {
     return false;
   }
-  const matchesConcreteType = isMemberNullBase(value) || isMemberBoolBase(value) || isMemberIntBase(value) || isMemberStringBase(value) || isMemberFloatBase(value) || isMemberDictionaryBase(value) || isMemberListBase(value) || isMemberClassBase(value) || isMemberEnumBase(value) || isMemberLookupBase(value) || isMemberDialogueLookupBase(value) || isMemberNSPropertyBase(value) || isMemberNSPropertyContractBase(value) || isMemberSpriteBase(value) || isMemberAudioBase(value) || isMemberFunctionBase(value) || isMemberNSFunctionBase(value) || isMemberNSFunction(value) || isMemberDelegateBase(value) || isMemberFunctionRefBase(value) || isMemberVector2Base(value) || isMemberVector2IntBase(value) || isMemberVector3Base(value) || isMemberVector3IntBase(value) || isMemberColorBase(value) || isMemberDecimalBase(value) || isMemberGenericBase(value);
+  const matchesConcreteType = isMemberNullBase(value) || isMemberBoolBase(value) || isMemberIntBase(value) || isMemberStringBase(value) || isMemberFloatBase(value) || isMemberDictionaryBase(value) || isMemberListBase(value) || isMemberClassBase(value) || isMemberEnumBase(value) || isMemberLookupBase(value) || isMemberDialogueLookupBase(value) || isMemberNSPropertyBase(value) || isMemberNSPropertyContractBase(value) || isMemberSpriteBase(value) || isMemberAudioBase(value) || isMemberFunctionBase(value) || isMemberNSFunctionBase(value) || isMemberNSFunction(value) || isMemberDelegateBase(value) || isMemberActionBase(value) || isMemberFunctionRefBase(value) || isMemberVector2Base(value) || isMemberVector2IntBase(value) || isMemberVector3Base(value) || isMemberVector3IntBase(value) || isMemberColorBase(value) || isMemberDecimalBase(value) || isMemberGenericBase(value);
   if (!matchesConcreteType) return false;
   if (!isValidDocsText(v?.docsText)) return false;
   if (typeof v?.name !== "string") return false;
@@ -38258,8 +38841,8 @@ function isMemberOverrideProps(value) {
   if (!isEpochMillis(v?.updatedAt)) return false;
   if (v.getter !== void 0 && !isNSGetter(v.getter)) return false;
   if (v.setter !== void 0 && v.setterCode === void 0) return false;
-  if (v.setterCode !== void 0 && !isNSVoidAction(v.setter)) return false;
-  if (v.setter !== void 0 && !isNSVoidAction(v.setter)) return false;
+  if (v.setterCode !== void 0 && !isNSVoidBody(v.setter)) return false;
+  if (v.setter !== void 0 && !isNSVoidBody(v.setter)) return false;
   const isCallableOverride = v.kind === 13 /* Function */ || v.kind === 23 /* NSFunction */;
   if (isCallableOverride) {
     if (!isValidCallableIdentifier(v.name)) return false;
@@ -40142,6 +40725,18 @@ function substituteMember(member, env, members) {
     };
     return substituted;
   }
+  if (isMemberActionBase(resolved)) {
+    let argumentsChanged = false;
+    const argumentTypes = resolved.argumentTypes.map((argument2) => {
+      const substituted2 = substituteNestedTypeInfo(argument2, env, members);
+      if (substituted2 === argument2) return argument2;
+      argumentsChanged = true;
+      return { ...substituted2, name: argument2.name };
+    });
+    if (!argumentsChanged) return resolved;
+    const substituted = { ...resolved, argumentTypes };
+    return substituted;
+  }
   return resolved;
 }
 function substituteNestedTypeInfo(typeInfo, env, members) {
@@ -40199,6 +40794,14 @@ function substituteNestedTypeInfo(typeInfo, env, members) {
       )
     };
   }
+  if (typeInfo.type === 26 /* NSAction */) {
+    return {
+      ...typeInfo,
+      argumentTypes: typeInfo.argumentTypes.map(
+        (argument2) => substituteNestedTypeInfo(argument2, env, members)
+      )
+    };
+  }
   return typeInfo;
 }
 function genericBindingTypeInfo(rawMember, env, members) {
@@ -40551,6 +41154,9 @@ var init_generics = __esm({
       23 /* NSFunction */,
       24 /* FunctionRef */,
       25 /* NSDelegate */,
+      // A signature carrier, not a binding target (P62 §2.1): `NeoAction<T>`
+      // threads T through substitution, but no `T` is ever *bound* to an action.
+      26 /* NSAction */,
       21 /* Generic */
     ]);
   }
@@ -42857,6 +43463,9 @@ function primitiveFallbackValue(document, member) {
       }
     };
   }
+  if (member.kind === 26 /* NSAction */) {
+    return { value: { listeners: [] } };
+  }
   if (member.kind === 21 /* Generic */) {
     throw new Error(
       `Unreachable: Generic member "${member.name}" must be substituted through its binding environment before default value construction \u2014 a substitution site was skipped upstream (https://github.com/ryanbliss/neo-compose-specs/tree/main/new-features/complete/class-generics.md \xA74.1).`
@@ -44744,13 +45353,23 @@ function renderMemberType(context, member, enclosingClassId) {
         )
       ].join(", ")}>`;
       break;
+    case "action":
+      value = renderActionType(
+        member.arguments.map((argument2) => renderType(context, argument2.type))
+      );
+      break;
   }
   if ((member.kind === "class" || member.kind === "generic") && member.partial === true) {
     value = `Partial<${value}>`;
   }
   if (member.kind === "generic") return value;
+  if (member.kind === "action") return value;
   return nullable && value !== "null" ? `${value}?` : value;
 }
+function renderActionType(argumentTypes) {
+  if (argumentTypes.length === 0) return "NeoAction";
+  return `NeoAction<${argumentTypes.join(", ")}>`;
+}
 function renderLookupEntryType(context, collectionMemberId) {
   const collection = required(
     context.members,
@@ -44837,6 +45456,10 @@ function renderType(context, type) {
         ...type.argumentTypes.map((argument2) => renderType(context, argument2))
       ].join(", ")}>`;
       break;
+    case "action":
+      return renderActionType(
+        type.argumentTypes.map((argument2) => renderType(context, argument2))
+      );
   }
   return type.nullable && value !== "null" ? `${value}?` : value;
 }
@@ -44851,6 +45474,38 @@ function renderDefault(context, member) {
   if ("init" in value) return value.init.code;
   return renderDefaultValue(context, member, value);
 }
+function renderActionListeners(context, member, value) {
+  if (!isObject2(value)) {
+    throw new Error(
+      `NeoAction member ${member.name} stores a default that is not a listener set.`
+    );
+  }
+  const { listeners } = value;
+  if (!Array.isArray(listeners)) {
+    throw new Error(
+      `NeoAction member ${member.name} stores a default with no listeners array.`
+    );
+  }
+  const names = listeners.map((listener, index) => {
+    if (!isObject2(listener)) {
+      throw new Error(
+        `NeoAction member ${member.name} listener ${index} is not a member target.`
+      );
+    }
+    if (typeof listener.memberId !== "string") {
+      throw new Error(
+        `NeoAction member ${member.name} listener ${index} is missing memberId.`
+      );
+    }
+    if (listener.valueId !== null && listener.valueId !== void 0) {
+      throw new Error(
+        `NeoAction member ${member.name} listener ${index} is instance-bound, which no declaration default can spell.`
+      );
+    }
+    return required(context.members, listener.memberId, "action listener").name;
+  });
+  return `[${names.join(", ")}]`;
+}
 function initDefaultSource(member) {
   const value = member.defaultValue;
   if (value === null || value === void 0) return void 0;
@@ -44902,6 +45557,9 @@ function renderDefaultValue(context, member, wrapper) {
     }
     return `new ${target.name}${assignments.length ? ` { ${assignments.join(", ")} }` : "()"}`;
   }
+  if (member.kind === "action") {
+    return renderActionListeners(context, member, value);
+  }
   if (member.kind === "functionRef" && isObject2(value) && typeof value.functionMemberId === "string") {
     return required(
       context.members,
@@ -46962,7 +47620,7 @@ function isNSBoolGetter2(value) {
   if (value.typeInfo.type !== 1 /* Bool */) return false;
   return value.typeInfo.required === true;
 }
-function isNSVoidAction2(value) {
+function isNSVoidBody2(value) {
   if (!isNSGetter(value)) return false;
   if (value.typeInfo.type !== 0 /* Null */) return false;
   return value.typeInfo.required === true;
@@ -46995,7 +47653,7 @@ function isUILogicAction(value) {
   if (typeof v !== "object") return false;
   if (v === null) return false;
   if (v.type !== 0 /* UI */) return false;
-  if (!isNSVoidAction2(v.action)) return false;
+  if (!isNSVoidBody2(v.action)) return false;
   return isUIRenderableAction(v.action);
 }
 function isCodeLogicAction(value) {
@@ -47006,7 +47664,7 @@ function isCodeLogicAction(value) {
   if (!isNonEmptyString(v.sourceFunctionId)) return false;
   if (!isDialogueSourceIdentifier(v.sourceFunctionName)) return false;
   if (typeof v.code !== "string") return false;
-  return isNSVoidAction2(v.action);
+  return isNSVoidBody2(v.action);
 }
 function isNonEmptyString(value) {
   return typeof value === "string" && value.length > 0;
@@ -50678,6 +51336,30 @@ function lowerFieldMember(context, ownerClass, declaration, id2, commonInput, ba
       }))
     };
   }
+  if (name === "NeoAction") {
+    if (partial) {
+      throw new Error("Partial<T> requires a Class or Class generic target.");
+    }
+    if (declaration.type.nullable) {
+      throw new Error(
+        `NeoAction member ${ownerClass.name}.${declaration.name} cannot be nullable; an action's rest state is an empty listener list.`
+      );
+    }
+    return {
+      ...common,
+      kind: "action",
+      // An action is structurally void, so every type argument is a
+      // parameter — there is no leading return slot to skip. `required` is
+      // fixed false because nullability has no meaning here (P62 §2.1).
+      required: false,
+      arguments: fieldType.arguments.map((argumentType, index) => ({
+        name: `p${index + 1}`,
+        type: lowerType(context, argumentType, ownerClass),
+        source: span(declaration),
+        selectionSpan: span(declaration)
+      }))
+    };
+  }
   if (name === "bool" || name === "null") {
     return { ...common, kind: name };
   }
@@ -51267,6 +51949,20 @@ function lowerType(context, type, ownerClass) {
       argumentTypes: type.arguments.slice(1).map((argument2) => lowerType(context, argument2, ownerClass))
     };
   }
+  if (type.name === "NeoAction") {
+    if (nullable) {
+      throw new Error(
+        "NeoAction cannot be nullable; an action's rest state is an empty listener list."
+      );
+    }
+    return {
+      kind: "action",
+      nullable: false,
+      argumentTypes: type.arguments.map(
+        (argument2) => lowerType(context, argument2, ownerClass)
+      )
+    };
+  }
   const classId = context.classIdsByName.get(type.name);
   if (classId) {
     const parameters = context.genericParametersByClass.get(classId);
@@ -51371,6 +52067,77 @@ function manifestTypeFromAstType(type) {
     arguments: (type.typeArguments ?? []).map(manifestTypeFromAstType)
   };
 }
+function lowerActionDefault(context, expression, ownerClass, path) {
+  const elements = expression.kind === "litList" ? expression.elements : [expression];
+  const listeners = [];
+  const identities = /* @__PURE__ */ new Set();
+  elements.forEach((element, index) => {
+    const memberId = lowerActionListenerId(
+      context,
+      element,
+      ownerClass,
+      `${path}[${index}]`
+    );
+    if (identities.has(memberId)) {
+      throw new Error(
+        `NeoAction listener ${path}[${index}] repeats an earlier listener; a listener set holds each target once.`
+      );
+    }
+    identities.add(memberId);
+    listeners.push({ memberId, valueId: null });
+  });
+  return { listeners };
+}
+function lowerActionListenerId(context, element, ownerClass, path) {
+  let current = element;
+  while (current.kind === "annotated") current = current.expression;
+  if (current.kind === "lambda") {
+    throw new Error(
+      `NeoAction listener ${path} is a lambda. A listener must be a member reference: extract the body to an NSFunction member and subscribe that member instead.`
+    );
+  }
+  const name = actionListenerSymbol(current);
+  if (name === null) {
+    throw new Error(
+      `NeoAction listener ${path} must name a callable member on the current Class.`
+    );
+  }
+  const classId = materializedId(ownerClass, "class", ownerClass.name);
+  const memberId = effectiveMemberIdByName(context, classId, name);
+  if (memberId === null) {
+    throw new Error(
+      `NeoAction listener ${path} names ${JSON.stringify(name)}, which ${ownerClass.name} does not declare or inherit.`
+    );
+  }
+  const declaration = context.sourceMembersById.get(memberId)?.member;
+  if (declaration === void 0) return memberId;
+  if (declaration.kind === "function") {
+    if (declaration.type.name !== "void") {
+      throw new Error(
+        `NeoAction listener ${path} targets ${declaration.name}, which returns a value; a listener must be void.`
+      );
+    }
+    if (declaration.modifiers.includes("async")) {
+      throw new Error(
+        `NeoAction listener ${path} targets deferred ${declaration.name}; listeners are immediate-only.`
+      );
+    }
+    return memberId;
+  }
+  if (declaration.type.name !== "NeoAction" && declaration.type.name !== "NeoDelegate") {
+    throw new Error(
+      `NeoAction listener ${path} targets ${declaration.name}, which is not a function, NSFunction, NSDelegate, or NeoAction member.`
+    );
+  }
+  return memberId;
+}
+function actionListenerSymbol(expression) {
+  if (expression.kind === "ident") return expression.name;
+  if (expression.kind !== "member") return null;
+  if (expression.receiver.kind !== "ident") return null;
+  if (expression.receiver.name !== "this") return null;
+  return expression.name;
+}
 function lowerExpressionValue(context, expression, declaredExpected, ownerClass, path, genericEnvironment = EMPTY_GENERIC_TYPE_ENVIRONMENT, sourceText) {
   const expected = substituteGenericTypeNames(
     declaredExpected,
@@ -51390,6 +52157,9 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
       sourceText
     );
   }
+  if (expected.name === "NeoAction") {
+    return lowerActionDefault(context, expression, ownerClass, path);
+  }
   switch (expression.kind) {
     case "litNull":
       if (!expected.nullable) {
@@ -51644,6 +52414,7 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
 }
 function positionRequiresEvaluation(context, expression, expected, ownerClass) {
   if (isStoredDelegateLiteral(expected, expression)) return false;
+  if (isStoredActionLiteral(expected, expression)) return false;
   return initializerRequiresEvaluation(
     context.declaredConstructors,
     expression,
@@ -51660,6 +52431,12 @@ function isStoredDelegateLiteral(type, expression) {
   while (current.kind === "annotated") current = current.expression;
   return current.kind === "lambda";
 }
+function isStoredActionLiteral(type, expression) {
+  if (type.name !== "NeoAction") return false;
+  let current = expression;
+  while (current.kind === "annotated") current = current.expression;
+  return current.kind === "litList";
+}
 function lambdaExpressionSource(source, pos) {
   let start = 0;
   for (let line = 1; line < pos.line; line += 1) {
@@ -51852,6 +52629,15 @@ function manifestTypeForMember(context, member) {
       ]
     };
   }
+  if (member.kind === "action") {
+    return {
+      name: "NeoAction",
+      nullable: false,
+      arguments: member.arguments.map(
+        (argument2) => manifestTypeForSchemaType(context, argument2.type)
+      )
+    };
+  }
   if (member.kind === "enum") {
     return {
       name: context.baseEnums.get(member.enumId)?.name ?? "object",
@@ -51952,6 +52738,14 @@ function manifestTypeForSchemaType(context, type) {
           )
         ]
       };
+    case "action":
+      return {
+        name: "NeoAction",
+        nullable: false,
+        arguments: type.argumentTypes.map(
+          (argument2) => manifestTypeForSchemaType(context, argument2)
+        )
+      };
   }
 }
 function genericParameterName(context, genericParamId) {
@@ -53286,6 +54080,15 @@ function memberRuntimeType(record3, context, seen = /* @__PURE__ */ new Set(), g
         ),
         nullable: !required2
       };
+    case 26 /* NSAction */:
+      if (!isMemberActionBase(member)) return UNKNOWN_TYPE2;
+      return {
+        kind: "action",
+        parameterTypes: member.argumentTypes.map(
+          (argument2) => toLanguageType(argument2, context, genericEnvironment)
+        ),
+        nullable: false
+      };
     case 21 /* Generic */: {
       const genericParamId = getOptionalString(member, "genericParamId");
       if (!genericParamId) return UNKNOWN_TYPE2;
@@ -53493,6 +54296,14 @@ function toLanguageType(type, context, genericEnvironment) {
         ),
         nullable: !required2
       };
+    case 26 /* NSAction */:
+      return {
+        kind: "action",
+        parameterTypes: type.argumentTypes.map(
+          (argument2) => toLanguageType(argument2, context, genericEnvironment)
+        ),
+        nullable: false
+      };
     case 21 /* Generic */: {
       const environmentEntry = genericEnvironment?.get(type.genericParamId);
       if (environmentEntry?.kind === "member") {
@@ -53785,7 +54596,7 @@ function compileNSGetter(code, ctx) {
     })
   );
 }
-function compileNSAction(code, ctx) {
+function compileNSVoidBody(code, ctx) {
   const context = createContext(ctx, {
     scriptKind: "action",
     dialogueContext: ctx.dialogueContext
@@ -53985,12 +54796,12 @@ __export(compiler_adapter_exports, {
   CompileError: () => CompileError,
   NEOSCRIPT_COMPILER_ADAPTER_REVISION: () => NEOSCRIPT_COMPILER_ADAPTER_REVISION,
   clearNeoScriptBodyCompileCache: () => clearNeoScriptBodyCompileCache,
-  compileNSAction: () => compileNSAction,
   compileNSConstructor: () => compileNSConstructor,
   compileNSFunction: () => compileNSFunction,
   compileNSGetter: () => compileNSGetter,
   compileNSInitializer: () => compileNSInitializer,
   compileNSSetter: () => compileNSSetter,
+  compileNSVoidBody: () => compileNSVoidBody,
   createNeoScriptCompilationProject: () => createNeoScriptCompilationProject
 });
 var init_compiler_adapter = __esm({
@@ -54494,6 +55305,14 @@ function substituteConstructorBaseType(typeInfo, owner, args) {
       )
     };
   }
+  if (typeInfo.type === 26 /* NSAction */) {
+    return {
+      ...typeInfo,
+      argumentTypes: typeInfo.argumentTypes.map(
+        (argument2) => substituteConstructorBaseType(argument2, owner, args)
+      )
+    };
+  }
   if (typeInfo.type === 6 /* List */ || typeInfo.type === 5 /* Dictionary */ || typeInfo.type === 9 /* Lookup */) {
     return {
       ...typeInfo,
@@ -54727,6 +55546,17 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen) {
       })
     };
   }
+  if (isMemberActionBase(resolved)) {
+    return {
+      type: 26 /* NSAction */,
+      required: false,
+      argumentTypes: resolved.argumentTypes.map((argument2) => {
+        const { name, ...typeInfo } = argument2;
+        void name;
+        return typeInfo;
+      })
+    };
+  }
   if (isMemberListBase(resolved) || isMemberDictionaryBase(resolved)) {
     const entry = members.find(
       (candidate) => candidate.id === resolved.entryMemberId
@@ -57010,8 +57840,20 @@ function pushConstructionFrame(ctx, label) {
     state.constructionStack.pop();
   };
 }
+function schemaRevisionUnchanged(previous, next) {
+  if (previous.length !== next.length) return false;
+  return previous.every((cell, index) => cell === next[index]);
+}
 function evaluatorResolutionCache(ctx) {
-  ctx.__resolutionCache ??= {
+  if (ctx.__resolutionCache !== void 0) return ctx.__resolutionCache;
+  const { project, members, classes } = ctx.vm;
+  const schemaRevision = ctx.vm.schemaRevision ?? NO_SCHEMA_REVISION;
+  const entry = resolutionCacheByMembers.get(members);
+  if (entry !== void 0 && entry.project === project && entry.classes === classes && schemaRevisionUnchanged(entry.schemaRevision, schemaRevision)) {
+    ctx.__resolutionCache = entry.cache;
+    return entry.cache;
+  }
+  const cache = {
     schemaKeyByMemberId: /* @__PURE__ */ new Map(),
     mergedSchemaByClassId: /* @__PURE__ */ new Map(),
     callableSignatureByKey: /* @__PURE__ */ new Map(),
@@ -57020,7 +57862,14 @@ function evaluatorResolutionCache(ctx) {
     compiledSetterByMemberId: /* @__PURE__ */ new Map(),
     effectiveStorageResolver: void 0
   };
-  return ctx.__resolutionCache;
+  resolutionCacheByMembers.set(members, {
+    project,
+    classes,
+    schemaRevision,
+    cache
+  });
+  ctx.__resolutionCache = cache;
+  return cache;
 }
 function createdSessionValuesSince(session, existingIds) {
   const created = [];
@@ -57089,7 +57938,7 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = []) {
   finalizeConstructorAllocations(runtimeCtx, void 0, ownsInvocationState);
   throw new NSGetterRuntimeError("Function ended without a return statement");
 }
-function evaluateNSAction(action, ctx) {
+function evaluateNSVoidBody(action, ctx) {
   const ownsInvocationState = ctx.__executionState === void 0;
   const writes = [];
   const runtimeCtx = withEvaluationRuntime(ctx, writes);
@@ -58006,6 +58855,11 @@ function evalInstructions(instructions, scope, ctx, options) {
         });
         break;
       }
+      case "addActionListener" /* addActionListener */:
+      case "removeActionListener" /* removeActionListener */: {
+        evalActionListenerInstruction(ins, scope, ctx, options);
+        break;
+      }
       case "collectionCall" /* collectionCall */: {
         evalCollectionMutationInstruction(ins, scope, ctx, options);
         break;
@@ -58187,6 +59041,61 @@ function evalInstructions(instructions, scope, ctx, options) {
   }
   return { kind: "fallthrough" };
 }
+function evalActionListenerInstruction(ins, scope, ctx, options) {
+  const operator = ins.type === "addActionListener" /* addActionListener */ ? "+=" : "-=";
+  if (ins.target.pointer.type === "variable" /* variable */) {
+    throw new NSGetterRuntimeError(
+      `NeoAction '${operator}' target must be a member, not a local variable.`
+    );
+  }
+  if (ins.target.writability === "setter" /* Setter */) {
+    throw new NSGetterRuntimeError(
+      `NeoAction '${operator}' cannot route through a property setter; a listener set is stored data, not a computed value.`
+    );
+  }
+  const listener = evalPointer(ins.listener, scope, ctx);
+  if (!isMemberDelegateTarget(listener)) {
+    throw new NSGetterRuntimeError(
+      `NeoAction '${operator}' listener must resolve to a member target; closures are not listeners.`
+    );
+  }
+  const current = actionListenersOf(
+    evalPointer(ins.target.pointer, scope, ctx),
+    () => `'${operator}' target`
+  );
+  const identity2 = nsActionListenerIdentity(listener);
+  const present = current.some(
+    (entry) => nsActionListenerIdentity(entry) === identity2
+  );
+  let listeners;
+  if (ins.type === "addActionListener" /* addActionListener */) {
+    if (present) return;
+    listeners = [
+      ...current,
+      { memberId: listener.memberId, valueId: listener.valueId }
+    ];
+  } else {
+    if (!present) return;
+    listeners = current.filter(
+      (entry) => nsActionListenerIdentity(entry) !== identity2
+    );
+  }
+  const value = { listeners };
+  validateAssignmentTarget(ins.target.pointer, scope, ctx);
+  applyOverlayAssignment(
+    ins.target.pointer,
+    ins.target.typeInfo,
+    value,
+    scope,
+    ctx
+  );
+  options.writes.push({
+    kind: "assign",
+    target: ins.target,
+    value,
+    ...resolvedDestinationFieldsForAssign(ins.target.pointer, scope, ctx)
+  });
+}
 function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx) {
   if (target.type === "staticMember" /* staticMember */) {
     if (ctx.storedConstructionReplay === true) {
@@ -59030,6 +59939,23 @@ function evalPointer(pointer, scope, ctx) {
       const args = pointer.args.map((arg) => evalPointer(arg, scope, ctx));
       return invokeDelegateValue(delegate, args, ctx, pointer.callSiteId);
     }
+    case "callAction" /* callAction */: {
+      const read = readActionWithOwner(pointer.action, scope, ctx);
+      const args = pointer.args.map((arg) => evalPointer(arg, scope, ctx));
+      consumeBudget(ctx, "workUnits", 1, "work unit");
+      invokeActionListeners(
+        actionListenersOf(
+          read.action,
+          () => actionPointerLabel(pointer.action, ctx)
+        ),
+        args,
+        ctx,
+        () => actionInvocationFrame(pointer.action, read.owner, ctx),
+        read.owner,
+        pointer.callSiteId
+      );
+      return null;
+    }
     case "functionErrorCheck" /* functionErrorCheck */: {
       try {
         evalPointer(pointer.call, scope, ctx);
@@ -59077,7 +60003,7 @@ function resolveEffectiveCallableMember(pointer, receiver, ctx) {
   const runtimeMember = resolveRuntimeSchemaMember(receiver, schemaKey, ctx);
   return runtimeMember ?? staticMember;
 }
-function invokeDelegateValue(value, args, ctx, callSiteId) {
+function invokeDelegateValue(value, args, ctx, callSiteId, ownerReceiver) {
   if (isNSDelegateClosureValueDraft(value)) {
     throw new NSGetterRuntimeError(
       "NeoDelegate closure has source code but no compiled action."
@@ -59097,6 +60023,11 @@ function invokeDelegateValue(value, args, ctx, callSiteId) {
       value.action.typeInfo.type === 0 /* Null */
     );
   }
+  if (isNSActionValue(value)) {
+    throw new NSGetterRuntimeError(
+      "An NSAction listener set is not a callable value; invoke the action member as a statement instead."
+    );
+  }
   if (!isMemberDelegateTarget(value)) {
     throw new NSGetterRuntimeError(
       "NeoDelegate value is neither a closure nor a bound member target."
@@ -59128,6 +60059,8 @@ function invokeDelegateValue(value, args, ctx, callSiteId) {
       );
     }
     receiver = row.value;
+  } else if (ownerReceiver !== null && ownerReceiver !== void 0) {
+    receiver = listenerReceiverOnOwner(member.id, ownerReceiver, ctx);
   }
   if (receiver !== null) {
     const schemaKey = cachedSchemaKeyForMember(member.id, ctx);
@@ -59211,6 +60144,17 @@ function invokeDelegateValue(value, args, ctx, callSiteId) {
       }
       return invokeDelegateValue(nested, args, ctx, callSiteId);
     }
+    if (member.kind === 26 /* NSAction */) {
+      invokeActionListeners(
+        storedActionListeners(member, receiver, ctx),
+        args,
+        ctx,
+        () => frame,
+        receiver,
+        callSiteId
+      );
+      return null;
+    }
     throw new NSGetterRuntimeError(
       `NeoDelegate target '${member.name}' resolves to non-callable member kind ${MemberKind[member.kind]}.`
     );
@@ -59218,6 +60162,107 @@ function invokeDelegateValue(value, args, ctx, callSiteId) {
     state.delegateStack.pop();
   }
 }
+function actionListenersOf(value, describe2) {
+  if (value === null || value === void 0) return [];
+  if (!isNSActionValue(value)) {
+    throw new NSGetterRuntimeError(
+      `NeoAction ${describe2()} holds a value that is not a valid listener set \u2014 every entry must be a distinct member target.`
+    );
+  }
+  return value.listeners;
+}
+function storedActionListeners(member, receiver, ctx) {
+  const describe2 = () => `target '${member.name}'`;
+  if (receiver !== null) {
+    const schemaKey = cachedSchemaKeyForMember(member.id, ctx);
+    if (schemaKey === null) {
+      throw new NSGetterRuntimeError(
+        `NeoAction target '${member.name}' has no schema key on its owning class.`
+      );
+    }
+    if (typeof receiver !== "object" || !Object.prototype.hasOwnProperty.call(receiver, schemaKey)) {
+      throw new NSGetterRuntimeError(
+        `NeoAction target '${member.name}' is missing from its receiver.`
+      );
+    }
+    return actionListenersOf(
+      resolveValueIfIdForMember(
+        receiver[schemaKey],
+        member,
+        ctx
+      ),
+      describe2
+    );
+  }
+  if (member.isStatic === true) {
+    return actionListenersOf(evalStaticMember(member.id, ctx), describe2);
+  }
+  if (member.defaultValue === void 0 || member.defaultValue === null) {
+    return [];
+  }
+  if (!isLiteralValueContent(member.defaultValue)) {
+    throw new NSGetterRuntimeError(
+      `NeoAction target '${member.name}' has an unevaluated initializer instead of a declaration default listener set.`
+    );
+  }
+  return actionListenersOf(member.defaultValue.value, describe2);
+}
+function listenerReceiverOnOwner(memberId, ownerReceiver, ctx) {
+  const schemaKey = cachedSchemaKeyForMember(memberId, ctx);
+  if (schemaKey === null) return null;
+  const onOwner = resolveRuntimeSchemaMember(ownerReceiver, schemaKey, ctx);
+  if (onOwner === null) return null;
+  return ownerReceiver;
+}
+function invokeActionListeners(listeners, args, ctx, frame, ownerReceiver, callSiteId) {
+  for (let index = 0; index < listeners.length; index += 1) {
+    try {
+      invokeDelegateValue(
+        listeners[index],
+        args,
+        ctx,
+        callSiteId,
+        ownerReceiver
+      );
+    } catch (error) {
+      if (!isCatchableNeoScriptRuntimeError(error)) throw error;
+      throw new NSGetterRuntimeError(
+        `${frame()} listener ${index} threw: ${error.message}`
+      );
+    }
+  }
+}
+function readActionWithOwner(pointer, scope, ctx) {
+  if (pointer.type !== "keyOf" /* keyOf */) {
+    return { action: evalPointer(pointer, scope, ctx), owner: null };
+  }
+  let owner = null;
+  const action = evalKeyOf(
+    pointer.keyOf,
+    scope,
+    ctx,
+    pointer.optional === true,
+    pointer.memberId,
+    (receiver) => {
+      owner = receiver;
+    }
+  );
+  return { action, owner };
+}
+function actionPointerLabel(pointer, ctx) {
+  if (pointer.type === "staticMember" /* staticMember */) {
+    return evalMemberById(ctx.vm, pointer.memberId)?.name ?? pointer.memberId;
+  }
+  if (pointer.type === "keyOf" /* keyOf */ && pointer.memberId !== void 0) {
+    return evalMemberById(ctx.vm, pointer.memberId)?.name ?? pointer.memberId;
+  }
+  return "action";
+}
+function actionInvocationFrame(pointer, owner, ctx) {
+  const name = actionPointerLabel(pointer, ctx);
+  if (owner === null || owner === void 0) return `${name}[default]`;
+  return `${name}[${findKnownRowIdByValueReference(owner, ctx) ?? "default"}]`;
+}
 function nativeReceiverDescription(member, receiver, receiverId) {
   if (receiverId !== void 0) return `, receiver value id '${receiverId}'`;
   return member.isStatic === true || receiver === null ? ", static receiver" : ", untracked instance receiver";
@@ -59762,6 +60807,8 @@ function runtimeTypeCheck(value, checkType, ctx, seenCollections = /* @__PURE__
       return typeof value === "string";
     case 25 /* NSDelegate */:
       return isNSDelegateClosureValue(value) || isMemberDelegateTarget(value);
+    case 26 /* NSAction */:
+      return isNSActionValue(value);
     case 11 /* Sprite */:
       return isRuntimeSpriteValue(value);
     case 12 /* Audio */:
@@ -59904,8 +60951,9 @@ function isRuntimeSpriteValue(value) {
   const sliceIndex = value.sliceIndex;
   return typeof sliceIndex === "number" && Number.isInteger(sliceIndex) && sliceIndex >= 0;
 }
-function evalKeyOf(keyOf, scope, ctx, optional = false, memberId) {
+function evalKeyOf(keyOf, scope, ctx, optional = false, memberId, onReceiver) {
   const receiver = evalPointer(keyOf.pointer, scope, ctx);
+  onReceiver?.(receiver);
   if (optional && (receiver === null || receiver === void 0)) {
     return null;
   }
@@ -60565,11 +61613,16 @@ function evalFunction(fn, scope, ctx) {
         }
         return c.includes(target);
       }
-      if (Array.isArray(c) && typeof target === "string" && c.includes(target)) {
-        return true;
-      }
-      const entries = collectionEntries(c, ctx);
-      return entries.some((e) => jsEqual(e, target));
+      const targetReferenceId = typeof target === "string" ? target : findKnownRowIdByValueReference(target, ctx);
+      let containsResolvedEntry = false;
+      iterateCollection(c, ctx, (entry, _key, valueId) => {
+        if (valueId !== null && valueId === targetReferenceId || jsEqual(entry, target)) {
+          containsResolvedEntry = true;
+          return 1 /* Break */;
+        }
+        return 0 /* Continue */;
+      });
+      return containsResolvedEntry;
     }
     case "decimalOp" /* decimalOp */: {
       const info = fn.info;
@@ -60724,6 +61777,7 @@ function evalFunction(fn, scope, ctx) {
             out[String(key)] = valueId ?? entry;
           }
         }
+        return 0 /* Continue */;
       });
       return out;
     }
@@ -60735,10 +61789,9 @@ function evalFunction(fn, scope, ctx) {
       const sentinel = /* @__PURE__ */ Symbol("not-found");
       let found = sentinel;
       iterateCollection(c, ctx, (entry, key) => {
-        if (found !== sentinel) return;
         if (!innerFn) {
           found = entry;
-          return;
+          return 1 /* Break */;
         }
         consumeBudget(ctx, "workUnits", 1, "work unit");
         const innerScope = pushParams(
@@ -60755,7 +61808,9 @@ function evalFunction(fn, scope, ctx) {
         );
         if (result.kind === "return" && result.value === true) {
           found = entry;
+          return 1 /* Break */;
         }
+        return 0 /* Continue */;
       });
       if (found !== sentinel) return found;
       if (fn.type === "first" /* first */) {
@@ -60793,6 +61848,7 @@ function evalFunction(fn, scope, ctx) {
           );
           out.push(result.value);
         }
+        return 0 /* Continue */;
       });
       return out;
     }
@@ -63256,6 +64312,7 @@ function snapshotCollectionMembership(collection, ctx) {
   const valid = forEachRawCollectionEntry(collection, ({ raw }) => {
     consumeBudget(ctx, "collectionVisits", 1, "collection visit");
     membership.push(raw);
+    return 0 /* Continue */;
   });
   if (valid) return membership;
   throw new NSGetterRuntimeError(
@@ -63266,21 +64323,23 @@ function forEachRawCollectionEntry(c, callback) {
   if (Array.isArray(c)) {
     for (let key = 0; key < c.length; key += 1) {
       const raw = c[key];
-      callback({
+      const control = callback({
         raw,
         key,
         valueId: typeof raw === "string" ? raw : null
       });
+      if (control === 1 /* Break */) break;
     }
     return true;
   }
   if (typeof c === "object" && c !== null) {
     for (const [key, raw] of Object.entries(c)) {
-      callback({
+      const control = callback({
         raw,
         key,
         valueId: typeof raw === "string" ? raw : null
       });
+      if (control === 1 /* Break */) break;
     }
     return true;
   }
@@ -63291,6 +64350,7 @@ function collectionEntries(c, ctx) {
   forEachRawCollectionEntry(c, ({ raw }) => {
     consumeBudget(ctx, "collectionVisits", 1, "collection visit");
     entries.push(resolveValueIfId(raw, ctx));
+    return 0 /* Continue */;
   });
   return entries;
 }
@@ -63298,7 +64358,7 @@ function iterateCollection(c, ctx, callback) {
   forEachRawCollectionEntry(c, ({ raw, key, valueId }) => {
     consumeBudget(ctx, "collectionVisits", 1, "collection visit");
     const entry = resolveValueIfId(raw, ctx);
-    callback(entry, key, valueId);
+    return callback(entry, key, valueId);
   });
 }
 function pushParams(parent, parameters, positional, isList) {
@@ -63312,7 +64372,7 @@ function pushParams(parent, parameters, positional, isList) {
   }
   return child;
 }
-var DELEGATE_LEXICAL_THIS, DELEGATE_LEXICAL_ROOT, NonCatchableNSGetterRuntimeError, NativeFunctionDelegateUnavailableError, CorruptNeoScriptIRError, NeoScriptResourceLimitError, NeoScriptWallClockTimeoutError, DEFAULT_NEO_SCRIPT_EXECUTION_BUDGET_LIMITS, liveListIndexesByProject, evaluatorOwnershipCachesByBase, MAX_CONSTRUCTION_DEPTH, MAX_LOOP_ITERATIONS, LazyValueOverlay, readonlyBindingErrorsByScope, READONLY_FOREACH_BINDING_ERROR, READONLY_CATCH_BINDING_ERROR;
+var DELEGATE_LEXICAL_THIS, DELEGATE_LEXICAL_ROOT, NonCatchableNSGetterRuntimeError, NativeFunctionDelegateUnavailableError, CorruptNeoScriptIRError, NeoScriptResourceLimitError, NeoScriptWallClockTimeoutError, DEFAULT_NEO_SCRIPT_EXECUTION_BUDGET_LIMITS, liveListIndexesByProject, evaluatorOwnershipCachesByBase, MAX_CONSTRUCTION_DEPTH, MAX_LOOP_ITERATIONS, resolutionCacheByMembers, NO_SCHEMA_REVISION, LazyValueOverlay, readonlyBindingErrorsByScope, READONLY_FOREACH_BINDING_ERROR, READONLY_CATCH_BINDING_ERROR;
 var init_evaluateNSGetter = __esm({
   "../src/view-models/neoscript-evaluator/evaluateNSGetter.ts"() {
     "use strict";
@@ -63366,6 +64426,8 @@ var init_evaluateNSGetter = __esm({
     evaluatorOwnershipCachesByBase = /* @__PURE__ */ new WeakMap();
     MAX_CONSTRUCTION_DEPTH = 64;
     MAX_LOOP_ITERATIONS = 1e4;
+    resolutionCacheByMembers = /* @__PURE__ */ new WeakMap();
+    NO_SCHEMA_REVISION = [];
     LazyValueOverlay = class extends Map {
       constructor(vm) {
         super();
@@ -75849,7 +76911,7 @@ function compileProjectMigrationAction(document, migration) {
   const thisClass = migration.targetClassId === null ? null : document.classes.find(
     (schemaClass2) => schemaClass2.id === migration.targetClassId
   ) ?? null;
-  return compileNSAction(migration.code, {
+  return compileNSVoidBody(migration.code, {
     project: document.project,
     members: document.members,
     classes: document.classes,
@@ -76306,7 +77368,7 @@ function compileDialogueLogicWithProjectData(request, projectData) {
   });
   return {
     target: 1 /* Action */,
-    action: compileNSAction(request.code, ctx)
+    action: compileNSVoidBody(request.code, ctx)
   };
 }
 function stringifyCompiledTextGetter(getter) {
@@ -76536,8 +77598,8 @@ function recompileDialogueNode(args) {
   if (nodeType === 2 /* Actions */) {
     const actions = args.node.actions;
     if (!Array.isArray(actions)) return false;
-    for (const actionValue of actions) {
-      const action = asObject(actionValue);
+    for (const actionValue2 of actions) {
+      const action = asObject(actionValue2);
       if (action?.type !== 0 /* EditMember */) continue;
       const logic = asObject(action.logic);
       if (!isCodeLogic(logic)) continue;
@@ -77051,13 +78113,16 @@ var init_project_version_static_value_writes = __esm({
           );
         }
         const normalizedExpected = normalizeMapKey(args.expectedMapKey);
+        const normalizedStored = normalizeMapKey(value.mapKey);
         if (this.createdValueIds.has(value.id)) {
           this.visitedCreatedValueIds.add(value.id);
           if (normalizedExpected === null) delete value.mapKey;
           else value.mapKey = normalizedExpected;
-        } else if (normalizeMapKey(value.mapKey) !== normalizedExpected) {
+        } else if (normalizedStored === null && normalizedExpected !== null) {
+          value.mapKey = normalizedExpected;
+        } else if (normalizedStored !== normalizedExpected) {
           throw new Error(
-            `${args.path} cannot bind value "${value.id}" from storage partition ${JSON.stringify(normalizeMapKey(value.mapKey) ?? "main")}; expected ${JSON.stringify(normalizedExpected ?? "main")}.`
+            `${args.path} cannot bind value "${value.id}" from storage partition ${JSON.stringify(normalizedStored ?? "main")}; expected ${JSON.stringify(normalizedExpected ?? "main")}.`
           );
         }
         if (args.graphValueIds.has(value.id)) {
@@ -77094,7 +78159,7 @@ var init_project_version_static_value_writes = __esm({
           }
           return;
         }
-        if (member.kind !== 7 /* Class */ && value.classId !== void 0) {
+        if (member.kind !== 7 /* Class */ && value.classId !== void 0 && value.classId !== null) {
           throw new Error(
             `${path} value "${value.id}" has classId but the member is not Class.`
           );
@@ -77230,6 +78295,14 @@ var init_project_version_static_value_writes = __esm({
           }
           return;
         }
+        if (isMemberActionBase(member)) {
+          if (!isNSActionValue(value.value)) {
+            throw new Error(
+              `${path} must store an NSAction listener set: { listeners: [...] } with a unique (memberId, valueId) identity per entry.`
+            );
+          }
+          return;
+        }
         if (isMemberClassBase(member)) {
           this.validateClass({ ...args, member, value });
           return;
@@ -80942,8 +82015,8 @@ function stripDialogueNodeDerivedBodies(node) {
   stripConditionCompanions(next.conditions);
   stripTextVariableCompanions(next.variables);
   if (Array.isArray(next.actions)) {
-    for (const actionValue of next.actions) {
-      const action = asRecord(actionValue);
+    for (const actionValue2 of next.actions) {
+      const action = asRecord(actionValue2);
       const logic = asRecord(action?.logic);
       if (logic?.type === 1 && typeof logic.code === "string") {
         delete logic.action;
@@ -81796,6 +82869,7 @@ function assertProjectVersionWholeGraphWritesValid(args) {
     changes: args.changes
   });
   assertStagedSchemaIdentifiersValid(projected, args.changes);
+  assertStagedActionListenersValid(projected, args.changes);
   assertStagedUnitySingletonValid(projected, args.changes);
   assertStagedProjectInterfaceValid(projected, args.changes);
   assertStagedTileGridReferencesValid(args.document, projected, args.changes);
@@ -82271,6 +83345,207 @@ function assertStagedSchemaIdentifiersValid(projected, changes) {
     }
   }
 }
+function assertStagedActionListenersValid(projected, changes) {
+  if (!changes.some(
+    (change) => ACTION_LISTENER_TRIGGER_RECORD_KINDS.has(change.recordKind)
+  )) {
+    return;
+  }
+  const actions = projected.members.filter(
+    (member) => member.kind === 26 /* NSAction */
+  );
+  if (actions.length === 0) return;
+  const membersById = new Map(
+    projected.members.map((member) => [member.id, member])
+  );
+  const valueIds = new Set(projected.values.map((value) => value.id));
+  const graded = [];
+  for (const action of actions) {
+    const listeners = authoredActionListeners(action);
+    if (listeners.length === 0) continue;
+    graded.push({
+      listeners,
+      declaration: substituteMemberForListenerGrading(action, projected),
+      label: describeActionMember(action, projected.classes)
+    });
+  }
+  const candidateRowIds = candidateActionListenerRowIds(projected, actions);
+  if (candidateRowIds.size > 0) {
+    const rowsById = new Map(
+      projected.values.map((value) => [value.id, value])
+    );
+    const owners = resolveOwnerMembersForValues(projected, candidateRowIds);
+    for (const [rowId, owner] of owners) {
+      if (owner.kind !== 26 /* NSAction */) continue;
+      const row = rowsById.get(rowId);
+      if (row === void 0) continue;
+      const listeners = storedRowActionListeners(row);
+      if (listeners.length === 0) continue;
+      const ownerId = getMemberId(owner);
+      if (ownerId === null) continue;
+      const action = membersById.get(ownerId);
+      if (action === void 0) continue;
+      graded.push({
+        listeners,
+        declaration: owner,
+        label: `${describeActionMember(action, projected.classes)} row "${rowId}"`
+      });
+    }
+  }
+  for (const entry of graded) {
+    const expected = callableArgumentTypes(entry.declaration);
+    if (expected === null) continue;
+    assertActionListenerSetValid({
+      listeners: entry.listeners,
+      expected,
+      owner: entry.label,
+      projected,
+      membersById,
+      valueIds
+    });
+  }
+}
+function candidateActionListenerRowIds(projected, actions) {
+  const actionIds = new Set(actions.map((action) => action.id));
+  const actionSchemaKeys = /* @__PURE__ */ new Set();
+  for (const schemaClass2 of projected.classes) {
+    for (const [schemaKey, memberId] of Object.entries(schemaClass2.schema)) {
+      if (actionIds.has(memberId)) actionSchemaKeys.add(schemaKey);
+    }
+  }
+  const candidates = /* @__PURE__ */ new Set();
+  for (const action of actions) {
+    if (typeof action.valueId === "string") candidates.add(action.valueId);
+  }
+  if (actionSchemaKeys.size === 0) return candidates;
+  for (const row of projected.values) {
+    if (!isPlainRecord4(row.value)) continue;
+    for (const schemaKey of actionSchemaKeys) {
+      const childId = row.value[schemaKey];
+      if (typeof childId === "string") candidates.add(childId);
+    }
+  }
+  return candidates;
+}
+function storedRowActionListeners(row) {
+  const body = row.value;
+  if (!isPlainRecord4(body)) return [];
+  const listeners = body.listeners;
+  return Array.isArray(listeners) ? listeners : [];
+}
+function getMemberId(member) {
+  const id2 = Reflect.get(member, "id");
+  return typeof id2 === "string" ? id2 : null;
+}
+function assertActionListenerSetValid(args) {
+  const { expected, owner, projected, membersById, valueIds } = args;
+  const identities = /* @__PURE__ */ new Map();
+  args.listeners.forEach((listener, index) => {
+    if (!isMemberDelegateTarget(listener)) {
+      throw new Error(
+        `${owner} listener ${index} is not a member target; a listener is always a { memberId, valueId } reference, never a closure.`
+      );
+    }
+    const identity2 = nsActionListenerIdentity(listener);
+    const firstIndex = identities.get(identity2);
+    if (firstIndex !== void 0) {
+      throw new Error(
+        `${owner} listener ${index} repeats the target identity of listener ${firstIndex} (member "${listener.memberId}", value ${listener.valueId ?? "default"}); a listener set holds each target once.`
+      );
+    }
+    identities.set(identity2, index);
+    if (listener.valueId !== null && !valueIds.has(listener.valueId)) {
+      throw new Error(
+        `${owner} listener ${index} names receiver value "${listener.valueId}", which this project version does not contain.`
+      );
+    }
+    const target = membersById.get(listener.memberId);
+    if (target === void 0) {
+      throw new Error(
+        `${owner} listener ${index} names member "${listener.memberId}", which this project version does not contain.`
+      );
+    }
+    if (!ACTION_LISTENER_TARGET_KINDS.has(target.kind)) {
+      throw new Error(
+        `${owner} listener ${index} targets member "${target.name}" (${target.id}), whose kind ${MemberKind[target.kind]} is not callable; a listener must be a Function, NSFunction, NSDelegate, or NSAction member.`
+      );
+    }
+    const signature = listenerTargetSignature(
+      substituteMemberForListenerGrading(target, projected)
+    );
+    if (signature === null) {
+      throw new Error(
+        `${owner} listener ${index} targets member "${target.name}" (${target.id}), whose callable signature could not be resolved.`
+      );
+    }
+    if (signature.deferred) {
+      throw new Error(
+        `${owner} listener ${index} targets deferred member "${target.name}" (${target.id}); listeners are immediate-only.`
+      );
+    }
+    if (!signature.returnsVoid) {
+      throw new Error(
+        `${owner} listener ${index} targets member "${target.name}" (${target.id}), which returns a value; a listener must be void.`
+      );
+    }
+    if (signature.argumentTypes.length !== expected.length) {
+      throw new Error(
+        `${owner} listener ${index} targets member "${target.name}" (${target.id}), which takes ${signature.argumentTypes.length} parameters; the action declares ${expected.length}.`
+      );
+    }
+    expected.forEach((argument2, position) => {
+      const candidate = signature.argumentTypes[position];
+      if (typeInfosInvariantlyEqual(argument2, candidate)) return;
+      throw new Error(
+        `${owner} listener ${index} targets member "${target.name}" (${target.id}), whose parameter ${position + 1} "${candidate.name}" does not match the action's parameter "${argument2.name}" after generic substitution.`
+      );
+    });
+  });
+}
+function authoredActionListeners(action) {
+  const defaultValue = action.defaultValue;
+  if (defaultValue === void 0 || defaultValue === null) return [];
+  if (!isLiteralValueContent(defaultValue)) return [];
+  const body = defaultValue.value;
+  if (!isPlainRecord4(body)) return [];
+  const listeners = body.listeners;
+  return Array.isArray(listeners) ? listeners : [];
+}
+function substituteMemberForListenerGrading(member, projected) {
+  const env = resolveDeclaringClassGenericEnv(member.id, projected.classes);
+  try {
+    return substituteMember(member, env, projected.members);
+  } catch {
+    return resolveMember2(member, projected.members);
+  }
+}
+function listenerTargetSignature(target) {
+  const argumentTypes = callableArgumentTypes(target);
+  if (argumentTypes === null) return null;
+  if (target.kind === 26 /* NSAction */) {
+    return { returnsVoid: true, argumentTypes, deferred: false };
+  }
+  const returnTypeInfo = Reflect.get(target, "returnTypeInfo");
+  if (!isNSFunctionReturnTypeInfo(returnTypeInfo)) return null;
+  return {
+    returnsVoid: returnTypeInfo.type === NS_TYPE_VOID,
+    argumentTypes,
+    deferred: Reflect.get(target, "deferred") === true
+  };
+}
+function callableArgumentTypes(member) {
+  const argumentTypes = Reflect.get(member, "argumentTypes");
+  if (!Array.isArray(argumentTypes)) return null;
+  const typed = argumentTypes.filter(isNSFunctionArgumentTypeInfo);
+  return typed.length === argumentTypes.length ? typed : null;
+}
+function describeActionMember(action, classes) {
+  const placement = findSchemaPlacement(action.id, classes);
+  if (placement === null) {
+    return `NSAction member "${action.name}" (${action.id})`;
+  }
+  return `NSAction member "${placement.ownerClass.name}.${action.name}" (${action.id})`;
+}
 function assertStagedUnitySingletonValid(projected, changes) {
   if (!changes.some(
     (change) => change.recordKind === "project" || change.recordKind === "member"
@@ -82328,7 +83603,7 @@ function assertStagedTileGridReferencesValid(current, projected, changes) {
     tileGridReferenceDeleteBlockedErrorData(blockers)
   );
 }
-var INTERFACE_VALIDATED_RECORD_KINDS;
+var INTERFACE_VALIDATED_RECORD_KINDS, ACTION_LISTENER_TRIGGER_RECORD_KINDS, ACTION_LISTENER_TARGET_KINDS;
 var init_project_version_whole_graph_validation = __esm({
   "../src/database/project-version-whole-graph-validation.ts"() {
     "use strict";
@@ -82342,12 +83617,22 @@ var init_project_version_whole_graph_validation = __esm({
     init_project_version_schema_commit();
     init_project_version_system_protection_writes();
     init_members();
+    init_generics();
+    init_inheritance();
+    init_neoscript();
     init_value_row_owner_members();
     init_init_backed_value_materialization();
     init_world_system_classes();
     init_project_world_reference_graph();
     init_project_record_semantics();
     INTERFACE_VALIDATED_RECORD_KINDS = /* @__PURE__ */ new Set(["member", "class", "constructor", "interface"]);
+    ACTION_LISTENER_TRIGGER_RECORD_KINDS = /* @__PURE__ */ new Set(["member", "class", "value"]);
+    ACTION_LISTENER_TARGET_KINDS = /* @__PURE__ */ new Set([
+      13 /* Function */,
+      23 /* NSFunction */,
+      25 /* NSDelegate */,
+      26 /* NSAction */
+    ]);
   }
 });
 
@@ -85164,6 +86449,7 @@ function buildValueLowerContext(state, manifest, options = {}) {
     pendingValues: registry.pendingValues,
     pendingLocalizedTexts: registry.pendingLocalizedTexts,
     loweredMemberIdByValueId: /* @__PURE__ */ new Map(),
+    storedClassSchemaMemberIds: /* @__PURE__ */ new Map(),
     pendingBindingMembersByClassId: registry.pendingBindingMembersByClassId,
     declaredConstructors: declaredConstructorIndex,
     initAuthoredRowIds: seedInitAuthoredRowIds(
@@ -85387,14 +86673,12 @@ function lowerMemberDefaultSourcesV4(state, analysis, manifest, options = {}) {
           (row) => !existingPendingValueIds.has(row.id)
         );
         if (pendingRows.length > 0) {
-          const existingRows = [...context.reconstructed].filter(
-            ([key, record3]) => !existingReconstructedKeys.has(key) && record3.recordKind === "value"
-          ).map(
-            ([, record3]) => staticValueSeedRow(
-              record3.fileFields,
-              context.loweredMemberIdByValueId.get(record3.recordId)
-            )
-          );
+          const existingRows = pendingSeedGraphRows({
+            context,
+            reconstructedBefore: existingReconstructedKeys,
+            pendingRows,
+            rootBody: lowered.value
+          });
           const bindingMembers = [
             ...context.pendingBindingMembersByClassId.values()
           ].filter(
@@ -85977,21 +87261,49 @@ function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
           `Default value ${binding.label}.${assignment.name} is constructor-projected and must be set through its named constructor argument.`
         );
       }
+      const childValueMember = recursivePartialMember(member, childMember);
+      const childSlice = assignmentSlices.get(assignment.name);
       const existingId = isObjectRecord2(baseBody) ? baseBody[assignment.name] : void 0;
-      const childId = typeof existingId === "string" ? existingId : annotatedValue(assignment.value).id;
-      if (childId === null || childId === void 0) {
+      const annotatedId = annotatedValue(assignment.value).id;
+      const storedId = typeof existingId === "string" ? existingId : annotatedId;
+      if (storedId !== null && storedId !== void 0) {
+        if (typeof existingId === "string" || context.state[`value:${storedId}`] !== void 0) {
+          body[assignment.name] = lowerValueRow(
+            context,
+            childValueMember,
+            assignment.value,
+            storedId,
+            binding,
+            environment,
+            childSlice
+          );
+          continue;
+        }
+        if (!isPendingId(storedId) && !isUuidV4Id(storedId)) {
+          context.loweringFailures.push({
+            message: `Default value ${binding.label}.${assignment.name} is annotated @id("${storedId}"), which names no existing row, and a new row's durable identity must be a UUID v4. Fix the id if it meant an existing row, or drop the @id to mint a fresh identity.`,
+            site: referenceSite(binding, assignment.value)
+          });
+        }
+      }
+      const placedId = sourceValueSymbol(context, assignment.value);
+      if (placedId !== null) {
         throw new Error(
-          `Default value ${binding.label}.${assignment.name} has no existing owned value row. Creating new default rows from source is not implemented by this slice.`
+          `Default value ${binding.label}.${assignment.name} cannot place existing value ${placedId} into a new structural slot. Create the nested value inline so the atomic construction transaction can own it.`
         );
       }
-      body[assignment.name] = lowerValueRow(
+      body[assignment.name] = lowerSeedChild(
         context,
-        recursivePartialMember(member, childMember),
+        childValueMember,
         assignment.value,
-        childId,
         binding,
+        `${binding.label}.${assignment.name}`,
+        /* @__PURE__ */ new Map(),
+        /* @__PURE__ */ new Map(),
+        void 0,
         environment,
-        assignmentSlices.get(assignment.name)
+        void 0,
+        childSlice
       );
     }
     return {
@@ -86132,14 +87444,13 @@ function lowerStoredBinding(context, binding, memberValueIds, seeds) {
     );
     if (pendingRows.length > 0) {
       const root = reconstructedOrStateValue(context, valueId);
-      const existingRows = [...context.reconstructed].filter(
-        ([key, record3]) => key !== `value:${valueId}` && !existingReconstructedKeys.has(key) && record3.recordKind === "value"
-      ).map(
-        ([, record3]) => staticValueSeedRow(
-          record3.fileFields,
-          context.loweredMemberIdByValueId.get(record3.recordId)
-        )
-      );
+      const existingRows = pendingSeedGraphRows({
+        context,
+        reconstructedBefore: existingReconstructedKeys,
+        pendingRows,
+        rootBody: root.value,
+        rootValueId: valueId
+      });
       const bindingMembers = [
         ...context.pendingBindingMembersByClassId.values()
       ].filter((pending) => !existingPendingBindingMemberIds.has(pending.id));
@@ -86174,6 +87485,105 @@ function memberValueId(memberId) {
 function reconstructedOrStateValue(context, valueId) {
   return context.reconstructed.get(`value:${valueId}`)?.fileFields ?? valueBase(context, valueId);
 }
+function pendingSeedGraphRows(args) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const [key, record3] of args.context.reconstructed) {
+    if (args.reconstructedBefore.has(key)) continue;
+    if (record3.recordKind !== "value") continue;
+    if (record3.recordId === args.rootValueId) continue;
+    candidates.set(record3.recordId, record3.fileFields);
+  }
+  const pendingIds = new Set(args.pendingRows.map((row) => row.id));
+  const bodies = /* @__PURE__ */ new Map();
+  for (const [id2, fields] of candidates) bodies.set(id2, fields.value);
+  for (const row of args.pendingRows) bodies.set(row.id, row.value);
+  const containedIds = /* @__PURE__ */ new Map();
+  const addContained = (containerId, id2) => {
+    if (typeof containerId !== "string") return;
+    const siblings = containedIds.get(containerId);
+    if (siblings === void 0) containedIds.set(containerId, [id2]);
+    else siblings.push(id2);
+  };
+  for (const [id2, fields] of candidates) addContained(fields.containerId, id2);
+  for (const row of args.pendingRows) addContained(row.containerId, row.id);
+  const collectReferenced = (body, into) => {
+    if (typeof body === "string") {
+      if (bodies.has(body)) into.add(body);
+      return;
+    }
+    if (Array.isArray(body)) {
+      for (const entry of body) collectReferenced(entry, into);
+      return;
+    }
+    if (!isObjectRecord2(body)) return;
+    for (const entry of Object.values(body)) collectReferenced(entry, into);
+  };
+  const childIds = (id2) => {
+    const children = new Set(containedIds.get(id2) ?? []);
+    collectReferenced(bodies.get(id2), children);
+    children.delete(id2);
+    return children;
+  };
+  const reachesPending = /* @__PURE__ */ new Map();
+  const visit = (id2) => {
+    const settled = reachesPending.get(id2);
+    if (settled !== void 0) return settled;
+    reachesPending.set(id2, false);
+    let reaches = pendingIds.has(id2);
+    for (const childId of childIds(id2)) {
+      if (visit(childId)) reaches = true;
+    }
+    reachesPending.set(id2, reaches);
+    return reaches;
+  };
+  const roots = new Set(
+    args.rootValueId === void 0 ? [] : containedIds.get(args.rootValueId) ?? []
+  );
+  collectReferenced(args.rootBody, roots);
+  for (const id2 of roots) visit(id2);
+  const rows = [];
+  for (const [id2, fields] of candidates) {
+    if (reachesPending.get(id2) !== true) continue;
+    rows.push(
+      staticValueSeedRow(fields, args.context.loweredMemberIdByValueId.get(id2))
+    );
+  }
+  return rows;
+}
+function retainedStoredClassBody(context, storedClassId, baseBody) {
+  const storedMemberIds = storedClassSchemaMemberIds(context, storedClassId);
+  const body = {};
+  for (const [key, childId] of Object.entries(baseBody)) {
+    const storedMemberId = storedMemberIds.get(key);
+    if (storedMemberId !== void 0 && !context.members.has(storedMemberId)) {
+      continue;
+    }
+    body[key] = childId;
+  }
+  return body;
+}
+function storedClassSchemaMemberIds(context, classId) {
+  const cached = context.storedClassSchemaMemberIds.get(classId);
+  if (cached !== void 0) return cached;
+  const memberIds = /* @__PURE__ */ new Map();
+  let current = classId;
+  const visited = /* @__PURE__ */ new Set();
+  while (current !== null && !visited.has(current)) {
+    visited.add(current);
+    const data = stateData(context, "class", current);
+    if (data === null) break;
+    if (isObjectRecord2(data.schema)) {
+      for (const [key, memberId] of Object.entries(data.schema)) {
+        if (typeof memberId === "string" && !memberIds.has(key)) {
+          memberIds.set(key, memberId);
+        }
+      }
+    }
+    current = stringOrNull(data.extendsClassId);
+  }
+  context.storedClassSchemaMemberIds.set(classId, memberIds);
+  return memberIds;
+}
 function staticValueSeedRow(value, loweredMemberId) {
   const id2 = stringOrNull(value.id);
   if (id2 === null) throw new Error("Authored value row is missing id.");
@@ -86258,7 +87668,7 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
     member,
     inheritedEnvironment
   );
-  if (resolvedMember.kind !== "delegate" && initializerRequiresEvaluation(
+  if (!isStoredCallableLiteral(resolvedMember.kind, expression) && initializerRequiresEvaluation(
     context.declaredConstructors,
     expression,
     memberClassName(context, resolvedMember),
@@ -86694,7 +88104,7 @@ function lowerValueRow(context, member, sourceExpression, expectedValueId, sourc
     member,
     environment
   );
-  if (resolvedMember.kind !== "delegate" && initializerRequiresEvaluation(
+  if (!isStoredCallableLiteral(resolvedMember.kind, expression) && initializerRequiresEvaluation(
     context.declaredConstructors,
     expression,
     memberClassName(context, resolvedMember),
@@ -86848,6 +88258,11 @@ function lowerValueBody(context, member, expression, base, source, environment,
           authoredSlice
         )
       };
+    case "action":
+      return {
+        ...next,
+        value: lowerActionValue(context, expression, source.ownerClassId)
+      };
     case "class":
       return lowerClassValue(
         context,
@@ -86920,7 +88335,11 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
     String(base.id ?? member.name)
   );
   const baseBody = isObjectRecord2(base.value) ? base.value : {};
-  const body = { ...baseBody };
+  const body = retainedStoredClassBody(
+    context,
+    currentClassId,
+    baseBody
+  );
   const assignmentSlices = objectInitializerSlices(authoredSlice);
   if (materializedConstruction !== "preserve") {
     lowerConstructorProjections(
@@ -88628,6 +90047,65 @@ function lowerFunctionReference(context, expression, ownerClassId) {
   }
   return { functionMemberId: target.id };
 }
+function isStoredCallableLiteral(kind, expression) {
+  if (kind === "delegate") return true;
+  if (kind !== "action") return false;
+  return expression.kind === "litList";
+}
+function lowerActionValue(context, expression, ownerClassId) {
+  const elements = expression.kind === "litList" ? expression.elements : [expression];
+  const listeners = [];
+  const identities = /* @__PURE__ */ new Set();
+  elements.forEach((element, index) => {
+    const listener = lowerActionListener(context, element, ownerClassId, index);
+    if (identities.has(listener.memberId)) {
+      throw new Error(
+        `NeoAction listener ${index} repeats an earlier listener; a listener set holds each target once.`
+      );
+    }
+    identities.add(listener.memberId);
+    listeners.push(listener);
+  });
+  return { listeners };
+}
+function lowerActionListener(context, element, ownerClassId, index) {
+  const { expression } = annotatedValue(element);
+  if (expression.kind === "lambda") {
+    throw new Error(
+      `NeoAction listener ${index} is a lambda. A listener must be a member reference: extract the body to an NSFunction member and subscribe that member instead.`
+    );
+  }
+  const path = memberPath(expression);
+  const symbol = path?.startsWith("this.") ? path.slice("this.".length) : path;
+  if (symbol === null || symbol === void 0 || symbol.includes(".")) {
+    throw new Error(
+      `NeoAction listener ${index} must name a function, NSFunction, NSDelegate, or NeoAction member on the current Class.`
+    );
+  }
+  if (ownerClassId === void 0) {
+    throw new Error(
+      `NeoAction listener ${symbol} cannot be resolved without its owning Class.`
+    );
+  }
+  const target = classMemberByName(context, ownerClassId, symbol);
+  if (target.kind === "action") return { memberId: target.id, valueId: null };
+  if (target.kind !== "function" && target.kind !== "scriptFunction" && target.kind !== "delegate") {
+    throw new Error(
+      `NeoAction listener ${symbol} does not resolve to a function, NSFunction, NSDelegate, or NeoAction member.`
+    );
+  }
+  if (target.returnType.kind !== "void") {
+    throw new Error(
+      `NeoAction listener ${symbol} returns a value; a listener must be void.`
+    );
+  }
+  if (target.kind !== "delegate" && target.deferred) {
+    throw new Error(
+      `NeoAction listener ${symbol} is deferred; listeners are immediate-only.`
+    );
+  }
+  return { memberId: target.id, valueId: null };
+}
 function lowerDelegateValue(context, expression, ownerClassId, authoredSlice) {
   if (expression.kind === "lambda") {
     const code = initializerExpressionSlice(authoredSlice);
@@ -88838,6 +90316,7 @@ function emitValueBody(context, member, value, visited, targetTyped, environment
   if (kind === 18) return referenceValue(context, member, body, true);
   if (kind === 24) return functionReferenceValue(context, body);
   if (kind === 25) return delegateValue(context, body);
+  if (kind === 26) return actionValue(context, body);
   if (kind === 12) {
     return fileValue(
       context,
@@ -89209,6 +90688,8 @@ function storedConstructorArgumentSource(context, type, value, environment, visi
       );
     case "delegate":
       return delegateValue(context, value);
+    case "action":
+      return actionValue(context, value);
     case "class": {
       if (typeof value !== "string") {
         throw new Error(
@@ -89417,6 +90898,12 @@ function schemaTypeForBindingMember(context, memberId, environment, visited = /*
         returnType: member.returnType,
         argumentTypes: member.arguments.map((argument2) => argument2.type)
       };
+    case "action":
+      return {
+        kind: "action",
+        nullable: false,
+        argumentTypes: member.arguments.map((argument2) => argument2.type)
+      };
     case "generic":
       return schemaTypeForBindingMember(
         context,
@@ -89524,6 +91011,8 @@ function storedSchemaTypeName(context, type, environment, valueId) {
       return "Dialogue";
     case "delegate":
       return "object";
+    case "action":
+      return "object";
     case "null":
       return "null";
   }
@@ -90139,6 +91628,45 @@ function delegateValue(context, body) {
   }
   return target.name;
 }
+function actionValue(context, body) {
+  if (!isObjectRecord2(body)) {
+    throw new Error("NSAction value is not a listener set.");
+  }
+  if (!Array.isArray(body.listeners)) {
+    throw new Error("NSAction value is missing its listeners array.");
+  }
+  const names = body.listeners.map(
+    (listener, index) => actionListenerName(context, listener, index)
+  );
+  return `[${names.join(", ")}]`;
+}
+function actionListenerName(context, listener, index) {
+  if (!isObjectRecord2(listener)) {
+    throw new Error(`NSAction listener ${index} is not a member target.`);
+  }
+  if (typeof listener.code === "string") {
+    throw new Error(
+      `NSAction listener ${index} stores a closure; only member targets are listeners.`
+    );
+  }
+  if (typeof listener.memberId !== "string") {
+    throw new Error(`NSAction listener ${index} is missing memberId.`);
+  }
+  if (listener.valueId !== null && listener.valueId !== void 0) {
+    throw new Error(
+      `NSAction listener ${index} is instance-bound and cannot be represented by current project source.`
+    );
+  }
+  const target = context.members.get(listener.memberId);
+  if (target === void 0 || typeof target.name !== "string") {
+    throw new Error(`NSAction listener ${listener.memberId} was not pulled.`);
+  }
+  const kind = numberField(target, "kind");
+  if (kind !== 13 && kind !== 23 && kind !== 25 && kind !== 26) {
+    throw new Error(`NSAction listener ${listener.memberId} is not callable.`);
+  }
+  return target.name;
+}
 function fileValue(context, kind, label, body, required2) {
   if (body === null || body === void 0) {
     if (required2) {
@@ -95572,7 +97100,7 @@ async function runMigrate(workspace, subcommand, positional, targetRef, json, de
     );
     assertMigrationCheckWorkspaceIsValid(status);
     const candidate = localMigrationCheckCandidate(status);
-    const compileAction = dependencies.compileAction ?? compileNSAction;
+    const compileAction = dependencies.compileAction ?? compileNSVoidBody;
     const bodySourceLocator = createNeoScriptBodySourceLocator(
       workspace,
       status
@@ -95983,7 +97511,7 @@ async function runPendingMigrations(workspace, client, raw, migrations, onlyRef,
     const pinned = migration.action;
     const migrationCode = migration.code;
     const compiled = pinned !== void 0 && pinned !== null ? pinned : compileNeoScriptBodyOrThrow(
-      () => compileNSAction(migrationCode, {
+      () => compileNSVoidBody(migrationCode, {
         project: document.project,
         members: document.members,
         classes: document.classes,
@@ -96008,7 +97536,7 @@ async function runPendingMigrations(workspace, client, raw, migrations, onlyRef,
     for (const instance of instances) {
       let result;
       try {
-        result = evaluateNSAction(
+        result = evaluateNSVoidBody(
           compiled,
           {
             vm: {
@@ -97281,7 +98809,7 @@ async function runScript(workspace, command, options, dependencies = {}) {
       );
     } else if (command === "apply" || options.mode === "action") {
       compiled = compileNeoScriptBodyOrThrow(
-        () => compileNSAction(source, compileContext),
+        () => compileNSVoidBody(source, compileContext),
         bodySite("action"),
         null
       );
@@ -97445,7 +98973,10 @@ ${JSON.stringify(report2, null, 2)}`
     );
     return;
   }
-  const result = evaluateNSAction(compiled, evaluatorContext2);
+  const result = evaluateNSVoidBody(
+    compiled,
+    evaluatorContext2
+  );
   const report = {
     ok: true,
     writes: result.writes,
@@ -97695,12 +99226,12 @@ function buildStoredNeoScriptChecks(document) {
       }
       if (node.type === 2 /* Actions */) {
         if (!Array.isArray(node.actions)) continue;
-        node.actions.forEach((actionValue, actionIndex) => {
-          if (!isObjectRecord2(actionValue)) return;
-          if (actionValue.type !== 0 /* EditMember */) return;
-          const logic = isObjectRecord2(actionValue.logic) ? actionValue.logic : null;
+        node.actions.forEach((actionValue2, actionIndex) => {
+          if (!isObjectRecord2(actionValue2)) return;
+          if (actionValue2.type !== 0 /* EditMember */) return;
+          const logic = isObjectRecord2(actionValue2.logic) ? actionValue2.logic : null;
           if (logic?.type !== 1 /* Code */) return;
-          const actionId = stableRecordId(actionValue, `action-${actionIndex}`);
+          const actionId = stableRecordId(actionValue2, `action-${actionIndex}`);
           checks.push({
             recordKind: "dialogue-node",
             id: nodeId,
@@ -99567,7 +101098,9 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     changes: status.changes,
     binaryChanges: status.binaryChanges ?? []
   });
-  if (status.changes.length === 0) return status;
+  if (status.changes.length === 0 && status.authoredValueSeeds.size === 0) {
+    return status;
+  }
   const initConversions = status.initConversions ?? [];
   if (initConversions.length > 0 && options.json !== true) {
     for (const line of describeInitConversions(initConversions)) warn(line);
@@ -99672,7 +101205,7 @@ async function runPush(workspace, options, preparationOverride) {
   const status = candidate.status;
   const local = candidate.preparedLocal;
   preparation?.stop();
-  if (status.changes.length === 0) {
+  if (status.changes.length === 0 && status.authoredValueSeeds.size === 0) {
     if (options.json === true) {
       console.log(
         JSON.stringify({
@@ -100188,7 +101721,7 @@ async function prepareLocalCandidateV4(workspace, options = {}) {
   let sourceHash;
   let preparedLocal = null;
   let documentStatus = status;
-  if (status.changes.length > 0) {
+  if (status.changes.length > 0 || status.authoredValueSeeds.size > 0) {
     try {
       documentStatus = pushOptions.dryRun ? cloneStatusForDryRun(status) : status;
       preparedLocal = await prepareLocalPushArtifactsV4(
@@ -101616,7 +103149,7 @@ function compileMigrationAction(schema, migrationData, locator) {
   ) ?? null : null;
   const code = String(migrationData.code);
   return compileNeoScriptBodyOrThrow(
-    () => compileNSAction2(code, {
+    () => compileNSVoidBody2(code, {
       project: schema.project,
       members: schema.members,
       classes: schema.classes,
@@ -101637,7 +103170,7 @@ function compileMigrationAction(schema, migrationData, locator) {
     locator
   );
 }
-var compileNSAction2, compileNSFunction2, compileNSGetter2, compileNSSetter2, ProjectTransactionInterruptedError, ProjectTransactionFailedError, PROJECT_TRANSACTION_POLL_DELAYS_MS, LocalCandidateArtifactError, SERVER_MINTED_PUSH_RECORD_KINDS;
+var compileNSVoidBody2, compileNSFunction2, compileNSGetter2, compileNSSetter2, ProjectTransactionInterruptedError, ProjectTransactionFailedError, PROJECT_TRANSACTION_POLL_DELAYS_MS, LocalCandidateArtifactError, SERVER_MINTED_PUSH_RECORD_KINDS;
 var init_push = __esm({
   "src/commands/push.ts"() {
     "use strict";
@@ -101673,7 +103206,12 @@ var init_push = __esm({
     init_merge();
     init_push_change_intent();
     init_push_body_diagnostics();
-    ({ compileNSAction: compileNSAction2, compileNSFunction: compileNSFunction2, compileNSGetter: compileNSGetter2, compileNSSetter: compileNSSetter2 } = compiler_adapter_exports);
+    ({
+      compileNSVoidBody: compileNSVoidBody2,
+      compileNSFunction: compileNSFunction2,
+      compileNSGetter: compileNSGetter2,
+      compileNSSetter: compileNSSetter2
+    } = compiler_adapter_exports);
     ProjectTransactionInterruptedError = class extends Error {
       constructor(transactionId) {
         super(
@@ -101724,7 +103262,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.9",
-      cliVersion: "0.24.9",
+      cliVersion: "0.25.1",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -103179,7 +104717,11 @@ function preparedHookCandidate(workspace) {
   }
   try {
     const directory = realpathSync(configuredDirectory);
-    const cacheRoot = resolve4(workspace.root, ".neo", "test-build");
+    const cacheRoot = resolve4(
+      realpathSync(workspace.root),
+      ".neo",
+      "test-build"
+    );
     const pathFromRoot = relative6(cacheRoot, directory);
     if (isAbsolute2(pathFromRoot)) {
       throw new NeoTestPreparedCandidateError(
@@ -105792,7 +107334,7 @@ function runActions(node, label, subject, world, report, violate) {
     const ctx = evaluatorContext(subject, world);
     let result;
     try {
-      result = evaluateNSAction(compiled, ctx);
+      result = evaluateNSVoidBody(compiled, ctx);
     } catch (error) {
       if (error instanceof NativeFunctionDelegateUnavailableError) {
         const message = error.message;
@@ -108415,7 +109957,12 @@ async function main() {
           `${paintChangeKind(binary.action === "create" ? "create" : "update")} project-file bytes ${binary.symbol} (${binary.path}) \u2014 ${binary.action}`
         );
       }
-      if (status.conflictedFiles.length === 0 && status.parseErrors.length === 0 && status.changes.length === 0 && (status.binaryChanges?.length ?? 0) === 0) {
+      if (status.authoredValueSeeds.size > 0) {
+        console.log(
+          `  ${paintChangeKind("create")} ${status.authoredValueSeeds.size} member value seed(s)`
+        );
+      }
+      if (status.conflictedFiles.length === 0 && status.parseErrors.length === 0 && status.changes.length === 0 && status.authoredValueSeeds.size === 0 && (status.binaryChanges?.length ?? 0) === 0) {
         console.log(`${sym.ok} Working copy is clean.`);
       }
       return;