Vue3 Prop passing to data item to be able to manipulate values, not modelling data item actually, why?

I am using vue3 and wonder how to pass data the correct way.

My Component structure is one table (items loaded via pinia store): XTableComponent
The XTableComponent has a child: XModalComponent. In the rendered table I have a button in each row. @click on that stores the current item in a data item

XTableComponent:

<template>
   ...that mentioned table in each line a button with @click and the item in the iteration as param
   <x-model-component v-if="currentItem" :item="currentItem ref="x-modal"></x-modal-component>
</template>

<script>
export default {
   data: () => {
      return {
        currentItem: {},
        itemListStore: useItemListStore()
      }
   },
   computed: {
      itemList() {
         return this.itemListStore.list
      }
   methods: {
     showModal(item){
         this.currentItem = item
         this.$refs['x-modal'].show()
     }
   }

}
</script>

My Child component looks a bit like this:

XModalComponent:

<template>
 ....
<input v-model:value="innerItem.something" type="text">
<button @click="save">save</button>

</template>
<script>
export default {
   props: {
      item: Object
   },
   data: () => {
      return {
         innerItem: {}
      }
    }
   mounted() {
      this.innerItem = item
   },
   methods: {
      save() {
         console.log(this.innerItem) //this does not show the manipulated value of `something`
      }
   }
}
</script>

Now, if I manipulate the input in my child component, and trigger a click event, the value does not get changed on my data item ...

what did I get wrong in vue3 with reactiveness, proxeis and passing props?

p.s. my code is kind of pseude code here, so please be fair with me on typos, or obvious parts
that are missing

p.p.s. I am used to vue2 quite well, so maybe I mix concepts. please tell me that too.

p.p.p.s. my table renders correctly, the modal looks fine. i double checked all names and typos.

So, as we figured out, the problem came from the way innerItem.something was bound to the input, and some confusion around the v-model directive.

As a recap, the v-model directive is short-hand for setting a prop on a component and listening to an event which updates the value.

In Vue 2, that was:

<child-component
  :value="myValue"
  @input="(nevValue) => myValue = newValue"
/>

which is equivalent to

<child-component v-model="myValue"/>

and it allows a variable to be changed by parent as well as child ("two-way binding"). Note that property name and event matches that of a HTML input element (the "value" attribute and the "input" event), probably because it represents the most familiar case, where a value is bound to an input:

<input type="text" v-model="myText"/>

However, to allow for multiple two-way bindings on a component, Vue 2 also introduced a second way, which allows to bind to any of the child components props, not just "value". This is the .sync modifier:

<child-component :childComponentProp.sync="myVar"/>

which is equivalent to:

<child-component
  :childComponentProp="myVar"
  @update:childComponentProp="(newValue) => myVar = newValue"
/>

In Vue 3, they decided to unify the two, dropping .sync and instead allowing to pass a prop name to v-model similar to how slot names are passed to the v-slot directive, i.e. v-model:childComponentProp="myVar", and similar as v-slot alone is equivalent to v-slot:default, v-model alone is equivalent to v-model:modelValue. So it is equivalent to:

<my-component
  :modelValue="myValue"
  @update:modelValue="(nevValue) => myValue = newValue"
/>

But the above only applies for Vue components. When using v-model on an HTML input element, it sill behaves like in Vue 2 and binds to the "value" attribute and the "input" event. It is still equivalent to:

<input :value="myValue" @input="(nevValue) => myValue = nevValue"/>

However, that behavior is a special case of plain v-model (i.e. without a prop name). And I think this is where the confusion comes from.

Using v-model:value explicitly binds to the @update:value event, i.e. this

<input v-model:value="innerItem.something" type="text">

is equivalent to:

<input type="text"
  :value="innerItem.something"
  @update:value="(newValue) => innerItem.something = newValue" 
/>

but that event is not sent by a plain HTML element.

So long long story short, you have to use v-model= instead of v-model:value= when binding to a native input element.

Does that make sense? Hope it helps.